From ad5675c5dd3af6f85c4568a64d27b6bbc7314092 Mon Sep 17 00:00:00 2001 From: drieseng Date: Sun, 26 Jun 2016 18:44:36 +0200 Subject: [PATCH 01/16] Eliminate the length check. Minor performance improvement. --- src/Renci.SshNet/Common/PipeStream.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/Renci.SshNet/Common/PipeStream.cs b/src/Renci.SshNet/Common/PipeStream.cs index 7e89ef26..0286fd5e 100644 --- a/src/Renci.SshNet/Common/PipeStream.cs +++ b/src/Renci.SshNet/Common/PipeStream.cs @@ -195,7 +195,7 @@ if (count == 0) return 0; - int readLength = 0; + var readLength = 0; lock (_buffer) { @@ -211,7 +211,7 @@ } // fill the read buffer - for (; readLength < count && Length > 0 && _buffer.Count > 0; readLength++) + for (; readLength < count && _buffer.Count > 0; readLength++) { buffer[readLength] = _buffer.Dequeue(); } @@ -229,8 +229,8 @@ /// True if data available; otherwisefalse. private bool ReadAvailable(int count) { - return (Length >= count || _isFlushed) && - (Length >= (count + 1) || !BlockLastReadBuffer); + var length = Length; + return (_isFlushed || length >= count) && (length >= (count + 1) || !BlockLastReadBuffer); } /// @@ -267,7 +267,7 @@ _isFlushed = false; // if it were flushed before, it soon will not be. // queue up the buffer data - for (int i = offset; i < offset + count; i++) + for (var i = offset; i < offset + count; i++) { _buffer.Enqueue(buffer[i]); } From eb56b0fae8d1ce5648798ba7fee56fecf43cf4c9 Mon Sep 17 00:00:00 2001 From: drieseng Date: Sat, 2 Jul 2016 16:24:22 +0200 Subject: [PATCH 02/16] Also use Interlocked.Increment(ref long) on Windows Phone. --- src/Renci.SshNet/Sftp/SftpSession.cs | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/Renci.SshNet/Sftp/SftpSession.cs b/src/Renci.SshNet/Sftp/SftpSession.cs index 20ca72e5..93d52f46 100644 --- a/src/Renci.SshNet/Sftp/SftpSession.cs +++ b/src/Renci.SshNet/Sftp/SftpSession.cs @@ -45,16 +45,7 @@ namespace Renci.SshNet.Sftp { get { -#if WINDOWS_PHONE - lock (this) - { - this._requestId++; - } - - return (uint)this._requestId; -#else - return ((uint) Interlocked.Increment(ref _requestId)); -#endif + return (uint) Interlocked.Increment(ref _requestId); } } From 0d569fb260a2f0fb5dbdd625d08f2994817d0a2a Mon Sep 17 00:00:00 2001 From: drieseng Date: Sat, 2 Jul 2016 16:25:28 +0200 Subject: [PATCH 03/16] Remove conditional override of IsSingleByte as we'll only define the ASCIIEncoding class on target frameworks that do not support this override. --- src/Renci.SshNet/Common/ASCIIEncoding.cs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/Renci.SshNet/Common/ASCIIEncoding.cs b/src/Renci.SshNet/Common/ASCIIEncoding.cs index 5c18ce32..f37db557 100644 --- a/src/Renci.SshNet/Common/ASCIIEncoding.cs +++ b/src/Renci.SshNet/Common/ASCIIEncoding.cs @@ -191,19 +191,6 @@ namespace Renci.SshNet.Common return byteCount; } - -#if !SILVERLIGHT && !WINDOWS_PHONE - /// - /// Gets a value indicating whether the current encoding uses single-byte code points - /// - /// - /// This property is always true. - /// - public override bool IsSingleByte - { - get { return true; } - } -#endif // !SILVERLIGHT && !WINDOWS_PHONE } } From 6836cff7b84c0fcbde60939b4585392f937d05a9 Mon Sep 17 00:00:00 2001 From: drieseng Date: Sat, 2 Jul 2016 16:28:25 +0200 Subject: [PATCH 04/16] Sync APM and TAP implementation. --- src/Renci.SshNet/Shell.cs | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/src/Renci.SshNet/Shell.cs b/src/Renci.SshNet/Shell.cs index f4669edf..0674882e 100644 --- a/src/Renci.SshNet/Shell.cs +++ b/src/Renci.SshNet/Shell.cs @@ -140,19 +140,15 @@ namespace Renci.SshNet continue; } #elif FEATURE_STREAM_APM - var asyncResult = _input.BeginRead(buffer, 0, buffer.Length, delegate(IAsyncResult result) - { - // If input stream is closed and disposed already dont finish reading the stream - if (_input == null) - return; - - var read = _input.EndRead(result); - if (read > 0) + var asyncResult = _input.BeginRead(buffer, 0, buffer.Length, result => { - _channel.SendData(buffer, 0, read); - } + // If input stream is closed and disposed already don't finish reading the stream + if (_input == null) + return; - }, null); + var read = _input.EndRead(result); + _channel.SendData(buffer, 0, read); + }, null); WaitHandle.WaitAny(new[] { asyncResult.AsyncWaitHandle, _channelClosedWaitHandle }); From 6cf058a312b157559336c896deb1fcad86b25add Mon Sep 17 00:00:00 2001 From: drieseng Date: Sat, 2 Jul 2016 16:31:37 +0200 Subject: [PATCH 05/16] Add support for .NET Core 1.0 (.NETStandard 1.3). Introduce FileSystemAbstraction. --- README.md | 76 +- .../SshNet.Security.Cryptography.1.0.0.nupkg | Bin 182854 -> 0 bytes .../SshNet.Security.Cryptography.dll | Bin 41984 -> 0 bytes .../SshNet.Security.Cryptography.dll | Bin 40448 -> 0 bytes .../lib/sl4/SshNet.Security.Cryptography.xml | 1161 --------- .../lib/sl5/SshNet.Security.Cryptography.xml | 1161 --------- .../lib/wp71/SshNet.Security.Cryptography.xml | 1161 --------- .../lib/wp8/SshNet.Security.Cryptography.xml | 1161 --------- .../SshNet.Security.Cryptography.1.1.0.nupkg | Bin 0 -> 182529 bytes .../net20/SshNet.Security.Cryptography.dll | Bin 37376 -> 37888 bytes .../net20}/SshNet.Security.Cryptography.xml | 12 +- .../net40/SshNet.Security.Cryptography.dll | Bin 37888 -> 37888 bytes .../net40}/SshNet.Security.Cryptography.xml | 12 +- .../net45}/SshNet.Security.Cryptography.dll | Bin 37376 -> 37376 bytes .../net45}/SshNet.Security.Cryptography.xml | 12 +- .../SshNet.Security.Cryptography.dll | Bin 0 -> 39424 bytes .../SshNet.Security.Cryptography.xml | 12 +- .../SshNet.Security.Cryptography.dll | Bin 0 -> 37888 bytes .../SshNet.Security.Cryptography.xml | 12 +- .../SshNet.Security.Cryptography.dll | Bin 38912 -> 38912 bytes .../SshNet.Security.Cryptography.xml | 12 +- .../lib/sl4}/SshNet.Security.Cryptography.dll | Bin 37888 -> 37888 bytes .../lib/sl4/SshNet.Security.Cryptography.xml | 1163 +++++++++ .../lib/sl5}/SshNet.Security.Cryptography.dll | Bin 37888 -> 37888 bytes .../lib/sl5/SshNet.Security.Cryptography.xml | 1163 +++++++++ .../uap10.0}/SshNet.Security.Cryptography.dll | Bin 38912 -> 39424 bytes .../uap10.0}/SshNet.Security.Cryptography.xml | 12 +- .../wp71}/SshNet.Security.Cryptography.dll | Bin 37376 -> 37376 bytes .../lib/wp71/SshNet.Security.Cryptography.xml | 1163 +++++++++ .../lib/wp8}/SshNet.Security.Cryptography.dll | Bin 37376 -> 37376 bytes .../lib/wp8/SshNet.Security.Cryptography.xml | 1163 +++++++++ .../System.IO.4.1.0/System.IO.4.1.0.nupkg | Bin 0 -> 694059 bytes .../System.IO.4.1.0/ThirdPartyNotices.txt | 31 + .../dotnet_library_license.txt | 128 + .../System.IO.4.1.0/lib/MonoAndroid10/_._ | 0 packages/System.IO.4.1.0/lib/MonoTouch10/_._ | 0 packages/System.IO.4.1.0/lib/net45/_._ | 0 .../System.IO.4.1.0/lib/net462/System.IO.dll | Bin 0 -> 22184 bytes .../lib/portable-net45+win8+wp8+wpa81/_._ | 0 packages/System.IO.4.1.0/lib/win8/_._ | 0 packages/System.IO.4.1.0/lib/wp80/_._ | 0 packages/System.IO.4.1.0/lib/wpa81/_._ | 0 packages/System.IO.4.1.0/lib/xamarinios10/_._ | 0 packages/System.IO.4.1.0/lib/xamarinmac20/_._ | 0 .../System.IO.4.1.0/lib/xamarintvos10/_._ | 0 .../System.IO.4.1.0/lib/xamarinwatchos10/_._ | 0 .../System.IO.4.1.0/ref/MonoAndroid10/_._ | 0 packages/System.IO.4.1.0/ref/MonoTouch10/_._ | 0 packages/System.IO.4.1.0/ref/net45/_._ | 0 .../System.IO.4.1.0/ref/net462/System.IO.dll | Bin 0 -> 22184 bytes .../ref/netcore50/System.IO.dll | Bin 0 -> 29864 bytes .../ref/netcore50/System.IO.xml | 2151 ++++++++++++++++ .../ref/netcore50/de/System.IO.xml | 2151 ++++++++++++++++ .../ref/netcore50/es/System.IO.xml | 2090 +++++++++++++++ .../ref/netcore50/fr/System.IO.xml | 2201 ++++++++++++++++ .../ref/netcore50/it/System.IO.xml | 2123 ++++++++++++++++ .../ref/netcore50/ja/System.IO.xml | 2264 +++++++++++++++++ .../ref/netcore50/ko/System.IO.xml | 2262 ++++++++++++++++ .../ref/netcore50/ru/System.IO.xml | 2023 +++++++++++++++ .../ref/netcore50/zh-hans/System.IO.xml | 2237 ++++++++++++++++ .../ref/netcore50/zh-hant/System.IO.xml | 2246 ++++++++++++++++ .../ref/netstandard1.0/System.IO.dll | Bin 0 -> 30128 bytes .../ref/netstandard1.0/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.0/de/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.0/es/System.IO.xml | 2090 +++++++++++++++ .../ref/netstandard1.0/fr/System.IO.xml | 2201 ++++++++++++++++ .../ref/netstandard1.0/it/System.IO.xml | 2123 ++++++++++++++++ .../ref/netstandard1.0/ja/System.IO.xml | 2264 +++++++++++++++++ .../ref/netstandard1.0/ko/System.IO.xml | 2262 ++++++++++++++++ .../ref/netstandard1.0/ru/System.IO.xml | 2023 +++++++++++++++ .../ref/netstandard1.0/zh-hans/System.IO.xml | 2237 ++++++++++++++++ .../ref/netstandard1.0/zh-hant/System.IO.xml | 2246 ++++++++++++++++ .../ref/netstandard1.3/System.IO.dll | Bin 0 -> 29864 bytes .../ref/netstandard1.3/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.3/de/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.3/es/System.IO.xml | 2090 +++++++++++++++ .../ref/netstandard1.3/fr/System.IO.xml | 2201 ++++++++++++++++ .../ref/netstandard1.3/it/System.IO.xml | 2123 ++++++++++++++++ .../ref/netstandard1.3/ja/System.IO.xml | 2264 +++++++++++++++++ .../ref/netstandard1.3/ko/System.IO.xml | 2262 ++++++++++++++++ .../ref/netstandard1.3/ru/System.IO.xml | 2023 +++++++++++++++ .../ref/netstandard1.3/zh-hans/System.IO.xml | 2237 ++++++++++++++++ .../ref/netstandard1.3/zh-hant/System.IO.xml | 2246 ++++++++++++++++ .../ref/netstandard1.5/System.IO.dll | Bin 0 -> 30528 bytes .../ref/netstandard1.5/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.5/de/System.IO.xml | 2151 ++++++++++++++++ .../ref/netstandard1.5/es/System.IO.xml | 2090 +++++++++++++++ .../ref/netstandard1.5/fr/System.IO.xml | 2201 ++++++++++++++++ .../ref/netstandard1.5/it/System.IO.xml | 2123 ++++++++++++++++ .../ref/netstandard1.5/ja/System.IO.xml | 2264 +++++++++++++++++ .../ref/netstandard1.5/ko/System.IO.xml | 2262 ++++++++++++++++ .../ref/netstandard1.5/ru/System.IO.xml | 2023 +++++++++++++++ .../ref/netstandard1.5/zh-hans/System.IO.xml | 2237 ++++++++++++++++ .../ref/netstandard1.5/zh-hant/System.IO.xml | 2246 ++++++++++++++++ .../ref/portable-net45+win8+wp8+wpa81/_._ | 0 packages/System.IO.4.1.0/ref/win8/_._ | 0 packages/System.IO.4.1.0/ref/wp80/_._ | 0 packages/System.IO.4.1.0/ref/wpa81/_._ | 0 packages/System.IO.4.1.0/ref/xamarinios10/_._ | 0 packages/System.IO.4.1.0/ref/xamarinmac20/_._ | 0 .../System.IO.4.1.0/ref/xamarintvos10/_._ | 0 .../System.IO.4.1.0/ref/xamarinwatchos10/_._ | 0 .../Renci.SshNet.NET35.csproj | 34 +- .../Properties/AssemblyInfo.cs | 3 + .../Renci.SshNet.NETCore.xproj | 19 + src/Renci.SshNet.NETCore/project.json | 82 + .../Renci.SshNet.Silverlight5.csproj | 14 +- src/Renci.SshNet.Silverlight5/packages.config | 2 +- .../Classes/Common/PipeStreamTest.cs | 15 - .../Classes/PipeStreamTest_Dispose.cs | 26 - .../Renci.SshNet.Tests.csproj | 3 + .../Renci.SshNet.UAP10.csproj | 19 +- src/Renci.SshNet.UAP10/project.json | 2 +- src/Renci.SshNet.VS2015.sln | 22 + .../Renci.SshNet.WindowsPhone8.csproj | 28 +- .../packages.config | 3 +- .../Abstractions/CryptoAbstraction.cs | 30 +- .../Abstractions/DnsAbstraction.cs | 7 + .../Abstractions/FileSystemAbstraction.cs | 32 + src/Renci.SshNet/Common/Extensions.NET40.cs | 32 - .../Common/NetConfServerException.NET40.cs | 24 - .../Common/NetConfServerException.cs | 20 + .../Common/ProxyException.NET40.cs | 22 - src/Renci.SshNet/Common/ProxyException.cs | 21 +- src/Renci.SshNet/Common/ScpException.NET40.cs | 21 - src/Renci.SshNet/Common/ScpException.cs | 24 +- .../Common/SftpPathNotFoundException.NET40.cs | 24 - .../Common/SftpPathNotFoundException.cs | 22 +- .../SftpPermissionDeniedException.NET40.cs | 24 - .../Common/SftpPermissionDeniedException.cs | 22 +- .../SshAuthenticationException.NET40.cs | 24 - .../Common/SshAuthenticationException.cs | 22 +- .../Common/SshConnectionException.NET40.cs | 24 - .../Common/SshConnectionException.cs | 22 +- src/Renci.SshNet/Common/SshData.cs | 4 + src/Renci.SshNet/Common/SshException.NET40.cs | 25 - src/Renci.SshNet/Common/SshException.cs | 20 + .../SshOperationTimeoutException.NET40.cs | 21 - .../Common/SshOperationTimeoutException.cs | 22 +- ...SshPassPhraseNullOrEmptyException.NET40.cs | 24 - .../SshPassPhraseNullOrEmptyException.cs | 22 +- src/Renci.SshNet/Renci.SshNet.csproj | 18 +- src/Renci.SshNet/SftpClient.cs | 9 +- .../DnsAbstraction_GetHostAddresses.cs | 4 +- .../FileSystemAbstraction_EnumerateFiles.cs | 166 ++ .../Renci.SshNet.Shared.Tests.projitems | 1 + 146 files changed, 92514 insertions(+), 5118 deletions(-) delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/SshNet.Security.Cryptography.1.0.0.nupkg delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/sl4/SshNet.Security.Cryptography.xml delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.xml delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.xml delete mode 100644 packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.xml create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/SshNet.Security.Cryptography.1.1.0.nupkg rename packages/{SshNet.Security.Cryptography.1.0.0 => SshNet.Security.Cryptography.1.1.0}/lib/net20/SshNet.Security.Cryptography.dll (61%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/net40 => SshNet.Security.Cryptography.1.1.0/lib/net20}/SshNet.Security.Cryptography.xml (99%) rename packages/{SshNet.Security.Cryptography.1.0.0 => SshNet.Security.Cryptography.1.1.0}/lib/net40/SshNet.Security.Cryptography.dll (62%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3 => SshNet.Security.Cryptography.1.1.0/lib/net40}/SshNet.Security.Cryptography.xml (99%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/wp8 => SshNet.Security.Cryptography.1.1.0/lib/net45}/SshNet.Security.Cryptography.dll (63%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/net20 => SshNet.Security.Cryptography.1.1.0/lib/net45}/SshNet.Security.Cryptography.xml (99%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll rename packages/{SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81 => SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0}/SshNet.Security.Cryptography.xml (99%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll rename packages/{SshNet.Security.Cryptography.1.0.0/lib/net45 => SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3}/SshNet.Security.Cryptography.xml (99%) rename packages/{SshNet.Security.Cryptography.1.0.0 => SshNet.Security.Cryptography.1.1.0}/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll (60%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/netstandard1.0 => SshNet.Security.Cryptography.1.1.0/lib/portable-net45+win8+wpa81}/SshNet.Security.Cryptography.xml (99%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/sl5 => SshNet.Security.Cryptography.1.1.0/lib/sl4}/SshNet.Security.Cryptography.dll (62%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml rename packages/{SshNet.Security.Cryptography.1.0.0/lib/sl4 => SshNet.Security.Cryptography.1.1.0/lib/sl5}/SshNet.Security.Cryptography.dll (62%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.xml rename packages/{SshNet.Security.Cryptography.1.0.0/lib/uap10 => SshNet.Security.Cryptography.1.1.0/lib/uap10.0}/SshNet.Security.Cryptography.dll (58%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/uap10 => SshNet.Security.Cryptography.1.1.0/lib/uap10.0}/SshNet.Security.Cryptography.xml (99%) rename packages/{SshNet.Security.Cryptography.1.0.0/lib/net45 => SshNet.Security.Cryptography.1.1.0/lib/wp71}/SshNet.Security.Cryptography.dll (62%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml rename packages/{SshNet.Security.Cryptography.1.0.0/lib/wp71 => SshNet.Security.Cryptography.1.1.0/lib/wp8}/SshNet.Security.Cryptography.dll (62%) create mode 100644 packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.xml create mode 100644 packages/System.IO.4.1.0/System.IO.4.1.0.nupkg create mode 100644 packages/System.IO.4.1.0/ThirdPartyNotices.txt create mode 100644 packages/System.IO.4.1.0/dotnet_library_license.txt create mode 100644 packages/System.IO.4.1.0/lib/MonoAndroid10/_._ create mode 100644 packages/System.IO.4.1.0/lib/MonoTouch10/_._ create mode 100644 packages/System.IO.4.1.0/lib/net45/_._ create mode 100644 packages/System.IO.4.1.0/lib/net462/System.IO.dll create mode 100644 packages/System.IO.4.1.0/lib/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.IO.4.1.0/lib/win8/_._ create mode 100644 packages/System.IO.4.1.0/lib/wp80/_._ create mode 100644 packages/System.IO.4.1.0/lib/wpa81/_._ create mode 100644 packages/System.IO.4.1.0/lib/xamarinios10/_._ create mode 100644 packages/System.IO.4.1.0/lib/xamarinmac20/_._ create mode 100644 packages/System.IO.4.1.0/lib/xamarintvos10/_._ create mode 100644 packages/System.IO.4.1.0/lib/xamarinwatchos10/_._ create mode 100644 packages/System.IO.4.1.0/ref/MonoAndroid10/_._ create mode 100644 packages/System.IO.4.1.0/ref/MonoTouch10/_._ create mode 100644 packages/System.IO.4.1.0/ref/net45/_._ create mode 100644 packages/System.IO.4.1.0/ref/net462/System.IO.dll create mode 100644 packages/System.IO.4.1.0/ref/netcore50/System.IO.dll create mode 100644 packages/System.IO.4.1.0/ref/netcore50/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.dll create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.dll create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.dll create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml create mode 100644 packages/System.IO.4.1.0/ref/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.IO.4.1.0/ref/win8/_._ create mode 100644 packages/System.IO.4.1.0/ref/wp80/_._ create mode 100644 packages/System.IO.4.1.0/ref/wpa81/_._ create mode 100644 packages/System.IO.4.1.0/ref/xamarinios10/_._ create mode 100644 packages/System.IO.4.1.0/ref/xamarinmac20/_._ create mode 100644 packages/System.IO.4.1.0/ref/xamarintvos10/_._ create mode 100644 packages/System.IO.4.1.0/ref/xamarinwatchos10/_._ create mode 100644 src/Renci.SshNet.NETCore/Properties/AssemblyInfo.cs create mode 100644 src/Renci.SshNet.NETCore/Renci.SshNet.NETCore.xproj create mode 100644 src/Renci.SshNet.NETCore/project.json create mode 100644 src/Renci.SshNet/Abstractions/FileSystemAbstraction.cs delete mode 100644 src/Renci.SshNet/Common/Extensions.NET40.cs delete mode 100644 src/Renci.SshNet/Common/NetConfServerException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/ProxyException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/ScpException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SftpPathNotFoundException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SftpPermissionDeniedException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SshAuthenticationException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SshConnectionException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SshException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SshOperationTimeoutException.NET40.cs delete mode 100644 src/Renci.SshNet/Common/SshPassPhraseNullOrEmptyException.NET40.cs create mode 100644 test/Renci.SshNet.Shared.Tests/Abstractions/FileSystemAbstraction_EnumerateFiles.cs diff --git a/README.md b/README.md index f7924187..bdfdc718 100644 --- a/README.md +++ b/README.md @@ -59,41 +59,47 @@ This project was inspired by **Sharp.SSH** library which was ported from java an In our codebase, we use the following conditional compilation symbols to identity features supported by a given target framework: -Symbol | Description -:------------------------------- | :-------------------------------------------------------------------------------- -FEATURE_DIAGNOSTICS_TRACESOURCE | [TraceSource](https://msdn.microsoft.com/en-us/library/system.diagnostics.tracesource.aspx) is available -FEATURE_RNG_CSP | RandomNumberGenerator can be created using default ctor of RNGCryptoServiceProvider -FEATURE_RNG_CREATE | RandomNumberGenerator can be created using static Create method on RandomNumberGenerator -FEATURE_HASH_MD5 | -FEATURE_HASH_SHA1 | -FEATURE_HASH_SHA256 | -FEATURE_HASH_SHA384 | -FEATURE_HASH_SHA512 | -FEATURE_HASH_RIPEMD160 | -FEATURE_HMAC_MD5 | -FEATURE_HMAC_SHA1 | -FEATURE_HMAC_SHA256 | -FEATURE_HMAC_SHA384 | -FEATURE_HMAC_SHA512 | -FEATURE_HMAC_RIPEMD160 | -FEATURE_THREAD_SLEEP | Current thread can be suspended using static Sleep method on Thread class -FEATURE_THREAD_TAP | Task-based Asynchronous Pattern is supported -FEATURE_THREAD_THREADPOOL | ThreadPool is supported -FEATURE_MEMORYSTREAM_GETBUFFER | [MemoryStream](https://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx) features a [GetBuffer()](https://msdn.microsoft.com/en-us/library/system.io.memorystream.getbuffer.aspx) method which allows access to the byte array from which this stream was created, or the underlying array -FEATURE_MEMORYSTREAM_TRYGETBUFFER| [MemoryStream](https://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx) features a [TryGetBuffer(out ArraySegment)](https://msdn.microsoft.com/en-us/library/system.io.memorystream.trygetbuffer.aspx) method which allows access to the byte array from which this stream was created, or the underlying array -FEATURE_STREAM_TAP | [Stream](https://msdn.microsoft.com/en-us/library/system.io.stream.aspx) supports Task-based Asynchronous Pattern (TAP) -FEATURE_STREAM_APM | [Stream](https://msdn.microsoft.com/en-us/library/system.io.stream.aspx) supports Asynchronous Programming Model (APM) -FEATURE_STREAM_SYNC | [Stream](https://msdn.microsoft.com/en-us/library/system.io.stream.aspx) supports synchronous execution -FEATURE_SOCKET_TAP | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Task-based Asynchronous Pattern (TAP) -FEATURE_SOCKET_EAP | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Event-based Asynchronous Pattern (EAP) -FEATURE_SOCKET_APM | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Asynchronous Programming Model (APM) -FEATURE_SOCKET_SYNC | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports synchronous execution -FEATURE_SOCKET_POLL | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) features a [Poll(Int32,SelectMode)](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.poll.aspx) method -FEATURE_DNS_TAP | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports Task-based Asynchronous Pattern (TAP) -FEATURE_DNS_EAP | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports Event-based Asynchronous Pattern (EAP) -FEATURE_DNS_APM | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports Asynchronous Programming Model (APM) -FEATURE_DNS_SYNC | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports synchronous execution -FEATURE_REFLECTION_TYPEINFO | +Symbol | Description +:----------------------------------- | :-------------------------------------------------------------------------------- +FEATURE_ENCODING_ASCII | [Encoding.ASCII](https://msdn.microsoft.com/en-us/library/system.text.encoding.ascii(v=vs.110).aspx) is available +FEATURE_BINARY_SERIALIZATION | Binary serialization is supported. +FEATURE_DIAGNOSTICS_TRACESOURCE | [TraceSource](https://msdn.microsoft.com/en-us/library/system.diagnostics.tracesource.aspx) is available +FEATURE_DIRECTORYINFO_ENUMERATEFILES | [DirectoryInfo.EnumerationFiles(string)](https://msdn.microsoft.com/en-us/library/dd413343(v=vs.110).aspx) is available +FEATURE_RNG_CSP | RandomNumberGenerator can be created using default ctor of RNGCryptoServiceProvider +FEATURE_RNG_CREATE | RandomNumberGenerator can be created using static Create method on RandomNumberGenerator +FEATURE_HASH_MD5 | +FEATURE_HASH_SHA1_CREATE | +FEATURE_HASH_SHA1_MANAGED | +FEATURE_HASH_SHA256_CREATE | +FEATURE_HASH_SHA256_MANAGED | +FEATURE_HASH_SHA384_CREATE | +FEATURE_HASH_SHA384_MANAGED | +FEATURE_HASH_SHA512_CREATE | +FEATURE_HASH_SHA512_MANAGED | +FEATURE_HASH_RIPEMD160_CREATE | +FEATURE_HASH_RIPEMD160_MANAGED | +FEATURE_HMAC_MD5 | +FEATURE_HMAC_SHA1 | +FEATURE_HMAC_SHA256 | +FEATURE_HMAC_SHA384 | +FEATURE_HMAC_SHA512 | +FEATURE_HMAC_RIPEMD160 | +FEATURE_THREAD_SLEEP | Current thread can be suspended using static Sleep method on Thread class +FEATURE_THREAD_TAP | Task-based Asynchronous Pattern is supported +FEATURE_THREAD_THREADPOOL | ThreadPool is supported +FEATURE_MEMORYSTREAM_GETBUFFER | [MemoryStream](https://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx) features a [GetBuffer()](https://msdn.microsoft.com/en-us/library/system.io.memorystream.getbuffer.aspx) method which allows access to the byte array from which this stream was created, or the underlying array +FEATURE_MEMORYSTREAM_TRYGETBUFFER | [MemoryStream](https://msdn.microsoft.com/en-us/library/system.io.memorystream.aspx) features a [TryGetBuffer(out ArraySegment)](https://msdn.microsoft.com/en-us/library/system.io.memorystream.trygetbuffer.aspx) method which allows access to the byte array from which this stream was created, or the underlying array +FEATURE_STREAM_TAP | [Stream](https://msdn.microsoft.com/en-us/library/system.io.stream.aspx) supports Task-based Asynchronous Pattern (TAP) +FEATURE_STREAM_APM | [Stream](https://msdn.microsoft.com/en-us/library/system.io.stream.aspx) supports Asynchronous Programming Model (APM) +FEATURE_SOCKET_TAP | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Task-based Asynchronous Pattern (TAP) +FEATURE_SOCKET_EAP | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Event-based Asynchronous Pattern (EAP) +FEATURE_SOCKET_APM | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports Asynchronous Programming Model (APM) +FEATURE_SOCKET_SYNC | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) supports synchronous execution +FEATURE_SOCKET_POLL | [Socket](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx) features a [Poll(Int32,SelectMode)](https://msdn.microsoft.com/en-us/library/system.net.sockets.socket.poll.aspx) method +FEATURE_DNS_TAP | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports Task-based Asynchronous Pattern (TAP) +FEATURE_DNS_APM | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports Asynchronous Programming Model (APM) +FEATURE_DNS_SYNC | [Dns](https://msdn.microsoft.com/en-us/library/system.net.dns.aspx) supports synchronous execution +FEATURE_REFLECTION_TYPEINFO | ##Building SSH.NET diff --git a/packages/SshNet.Security.Cryptography.1.0.0/SshNet.Security.Cryptography.1.0.0.nupkg b/packages/SshNet.Security.Cryptography.1.0.0/SshNet.Security.Cryptography.1.0.0.nupkg deleted file mode 100644 index 25dc8ae758c9b1484bae9cc7a573472106bef9c8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 182854 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 Br(gg8 diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll deleted file mode 100644 index bed34e430fdfeb29aa5c0848679bd71e3cf99b27..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41984 zcmeHw34ByVw)g3Kd(B2dpu^rB0c{Dyga8H=1QIr74@k3U)+Pj#?wEze7zIV#Z~>RW z5%+zY!F8Mw8AZee9mR1SozYRB&wUx4H#*M1_dlnqyKjf26X(tM-uL@`Hl%Kys&lH& zId$sPa_inZd+B9l5|JH$2M-cGf-Cha)Zis*t~_HSDho`%CAR`5PiNq5SmplwrE)c~gmI*-To}XX4^$ZST@y z{#085(a(|MR;iynh^rrekK>OhQ{sl=n-iFS^|KKn{mjE`kZaPpjLQGxR}E_HZ76px z#~&xUB3_8j#pPY1G+ZhkAQ}`;?LOv@u`al7z%wjV`7NQfEr1)hAwZtU3cjsBKdQ}d zYHq4VqVV=OB2N5m$Didl3C)$?6snH^k$GjFSqF3z{w%*qL{luFM4xB9;>Wxh;fAVD%318+CX7XagNL~0$D^Uk=_WJvk{zbw1Gi;qz~dP zKpL2uN3Ic|%Pw%xRk$KIDZSa}fGyQEGPMcBjm>?zNW1rdJygP?L)7wR=prH70@!Y+{7L1`axm=PGrL?hUK*oHyMJmO+c$s;Gy z4H~1%Faoa#0`rN|Qkzb+@Y#-5u^UDkUn2RyYv(dXoPbsh!2AFhj#yFvo`F;B%rdhI zURC`rsXwqE$x{CaGE8O>ND~Pf;0#SP2YhmEFdNez8H5xyEC=U%rER?4 z$T&vP9HOP2DJpKXK|yw}5y?QB22^n>-|2Ot2|5y|8ZK^VrF`b!ppj8sgXP~NOV{7$ z0PDW5h9dB0Xrw-(FV?$5`YrlB_>Jra*^p%^Xmh97u!GF>Jg-wENHx7KuTymjS9%_K zlx;cb3DgU70KFMN>5xmwB2?|LI<$)jrxHZk)VyI}i1S>&aZcBk%9pn*(Otgf3M5xf zFx3Uoxp$9x8Ikn70h-3+8>i7dzUAA=lM_t$s47&y9`(9b^XRx5RBbUebJbq0W@q4K z##8bbbU5UJb;4#Zsnewz&|s$4pc#SBaHi(jO>tfmjpm7fO>Jc(rfAsCt`A1WHer+D z3_uq7CW&2vYLS(y3!JbO2PF#}FIm|w50xFt-q?Xo;2zLD)PYXmj&$&msy_dE#G>NB z3KEncaEz4Y>x6EB5qL=oQ%Y+`_p^&HfbLWsMjNL|kCvL?XC#H4brItz{W8Aly9ysZ zLv`R|G=4-(LHx-u;EGRzy*|%HMEi%-6zv}j(1_cN0m^EjWV_+Zyx0fZXz#^9AYE8A z0#g+m($1a8*lGKB*526#CjAV&p^Plb^P)T1w*;nf;r5(hrs2q0l4(L3bXEIEr^CyG zn>WQd>h-+wj2f6Om_{3OdPyA+Zm)7$^j$QHR_SBD&@-13EyK~ z+v!p82w%j2hF8TDtKI`9NIx~&;B)Q1i~|P7K@0?eIZAtNtV>^p zvv0V(?m9z3y_`OO4IqUBrSssH3K5_gyUQDx!K47egxxhD2BJOet|2iH?i9`?O~Y!y za%I~wD%wXJ4hEvl2ANDk2O-cyChsayjp1!)MSD~7dO=RssnffioH@Z1=YRutDC=Xx zZyP$bww-x0{1@E)!k6vLkKsS?_HVYeGcSgJ^}^Aa?aT*CWAVLdQW}fw_FhNsoM4(; z$qYAV^B%CJdq%wj8?_Uh1A&lrES9HqnS%O-EvE_p$NWVbRAxmvtQ1D~Dr3+xa4I)c zj&Ai4D4WNr74bU6pj8t|9n7o~=I6)KfXYqSpN!TvF@UsVO#P#QW@ zIEpv)h^?5Vm@jX)J92{NkQ$Ek3!1)6iS>I$ZKfMUhS0mezcditXv z?2}QP!E`rptSJ3}@>ZjNSkRXxD4t*%s&QIT`UB;Q-#zw3(B~BtcQCahD+7S?%U);v zwQE)e0%OG9^QI?ZWe`xZrxo0hgq6WSv0XXspGjC50+ctlt*`5v6`uzvzx-S2MM-$^ zr2yx?Wd{!?VaAsVoL#RkzaR-WzBJ$*mUY>wN!UpT%H^kRgHTwo zux;M;^ur$qeSH#a#)85YadPHSuXW9fG(uUQQX?5NEcJ#DZ+s&OGi;sD{P6q#Ou~%V z#D_2ZIX4M6+y<|?j(#!;H{4auOMms-B+RgVe%@#4)MU)CML0fw|IV(N;colg&0qc_ z2`}7N-ZUb$Nq7o=|VKhO_y5^TnT!}eSH$*x61`d`U- z;qKqK^S8T_@Z#fE+I!|Tfv%b1UhwxLZu}$(Gi)*E7JT_i5@xtdItHI_PsR(owDB*! z@@Ch(NL&BM)o*>6gc%=qrti+U$(Mv1w!F|u_w4D&&Fr|zu-K)C9rY5pDg00V| zU7Cy;wukm_zr=9RB{OWB`%m6@ZW3m=r_4R`j!4(MNDI9C;m89?m|=V9Q)0V02`^%s zH)gr#Bw>bo%Gqa@{VfSIJiv|p%Q257VTR4&(U)Hzk&GEO&Mm*+^r?jzJA1{X6 zb3ug3DX)zz>pxCST>o)O*XuvQPgws+N)Oh5f)`!?F~IA;=$daN;Mkf^FA9fBS_OEI z?jfZ{=aK#!5R1+)4_*KFc>Pz-g(s~4uzc-w{kL2&jW%W~y8csfwf-B<%<5dM1Q_J? zpF&Ao|8=Z1as784B*PpZdl`LXWrj&H7uLTjRj&huT-JdSGuoKt=sM69IGGtW0=056 z+Kxb`(;GNNg8>Ey#K0pN91;Uz9(E_DV^QopfipE6sNh1JvN^>|JOQzuN?7YiLmF*| zgHqNy9Ql{mI!x?~uXRKwWeav13q3j1+Ck8;_EnppN_6xRX2q9b>b0*xy-ZpAsx?}| zI#7&F=~DP+rOG;xBe8bm-Emn5GP*Y)MuBx8@D#R^T7u)Z`M z<#va44QX8~A}6+1bW*jS3&MY8)5BA;(Y;t9!&9@dvCH}xo|f%0+E^XK)3dSkXKf76 zwr6{cEQgWh%yMP916AM%3rW@k#%oO7Dv^-o38J(t7lvg9QA!rmFo~4_Lmj66Lf{T^ zsm>^Y)5vmzhDodh7$q=p3V|yKjLWDL546@Jeo#ta85s2?FQ<_6J5=$XX4Wbvi{7@2uJ z6>YbkNzL>2Xv6hPZk}%q`Z03zR7GpHhjL?`5LIo@+L|X-T{X7T;9Zp!@y@_=$`3EP zX8sVY$~kjdtfqU(O_v(T}fDKhQed!`aGIHA+dF3C7(sg0Xh)uwx9 z&vYWIUTbYh9Hpf;_B5(CJ@zIUB`jp(ZW6fcnNHZ%DzffJN=tR@trVGVxE|_+_m_lD zw?NNyB3oCgIz8C-OeyRz6q(lLp*m4xNhsdi*tUl4pS?UfzIESZhh zY)=Yb*;5xz#zMg!Kq!>fI`c6WY_=d(zLvU!k2yqS>GVROI(@eyv(cy;l+ko2vGj9A zkaYO82q8ndkn~7q>Dm_btnOrH(@-2KC3P#abZ1Kq-O0@USJ0LJ?Y@zv2P>A8U3AmT z>~j^m?i1aK%zai7s7B}@a(vNH6YmXdt2ci7W;ix4PU12xWYXY@PBWLpKUnG5KM0*3 zwUYP;3mNNLsI*ssWL>SGEL5U!#boyjDJvcC&?>s_eWrzuO-_;hD4lRSD>6O&^h_t* z+6lt-OeySYgiMeBhkDG|+R`E#yPO2kdS)iw)q>9kV?pm;VCmyZ1l7kobE=jK#7Go= zvcc0r!M$1$s9xQ{t9H`LyaW)6B+D>M1>BLX67)c5UdC8?>PBepy;k(j2Tu!2>~DoY z*Jv z6`l6ZN!){lj#Zve-68IwQ?0PECDfM0V_IqxXQb%#h}AQ#a61c`9t?V@6K?H<+IprF z_BM)4H$l&I!ahgH^k~pSmGB@gWZlm+teWHrije&%m9V3>R@O6xu(z{H)-!#uzYwY} zH*fX!mSs7|cJ=Y`D}Fkis%ocd zAz<541j=?g9Y`$r;^(ad-AgQ^vydo@=|*Jk;noT|cd8ba*hVbHckWaz_|mCW4M}DT z76LX5g|A#=4@BmkY^|ajnZ^5BtLRo}?z}>v%&2>z+25)fl)vq^p}E5ffik_0LdS1p zSayfmT<83=?9S*sEGvn-w2*O=D>6M6B=MIPGH!Sw(+(_&bFff}u2pS%giPWdEOe}K zA?tq5ZJ`ol6EfX{d!`XKImM%1^7Kq2vV2r@dKB-WPPnm!POGwKDq(MvP+O8A#G(`S zISIn`OegGX6 ze6ndN-a7LxRzwWhnww6?4=XC%gdYAncPSQJboOM+Eej^>L>Jo8iySHyI&Y-%ZpXCl>JZqP859-c7Zq?)Tl$?H0H~2A7 zxPt9+211<-$Z`g8hDuICc-rOgggy|Fog#;)_||_`3LlX}oZc6Z?=cX8tb5rv!#(4-^dokdS z=cbO4v{rEbf9>4VYA!tC+|;qCw6o`C)(EE2#!N-eO{us#H+38{t8;O3hCx0zrBD*j zO?9j^@!ZstIBU|I&xgd%O>trIb5lYt=cXiPv@y%kb5m{O0a%`&X=Ao=)P(ix%W&b; zPy?R55U7_6(SRTrZFoqEk5{!by3vOA<4!@@DQ`54-YX* zI6TCf(1(XuUd!Pj1``esb$FJB`9Q~I&g2XgN8}6@M`CRnJ440j-hdbgs%0ELL&f6p z87jW2GgNj$#gwhi{xA=Qv=$!9Is5jD!9!H&|e8+GU>9|tgo5N8Jmv2awt6xn;D$Y<0 ztirhp5b+U@Bt+>>&^SSp;`R)z@-T&*@km0FhJuHnbP%CR_rNMQQ^`q>Bvh#$5P3j@ zXMYA(xtK(bdL$u9af8GS64dyU4t~l>DnJ8A^J%NUHgM1YWv9!lKO)rn)`3{1#G3rhE}j$_Knnb z19n$=*8zFF>wv9Q**#L54|qIPHjvaF1aH+^H<7YEvf)|`vMdj8xZ+h(*&aMvC3_P5 z?kV1W#fB^IBcTp{4vpVSvc=c0D#dA-IlM_Xsy9y<7f45_$iTk@>!9LXfu0Q%*EEg8v-xYG% z-<6or#w^G7cV_^w?C)O2Y@?Z3zw!NDfzC_KAX11?(3ErwKSngNJSg$J^SZ2cd`9Ua)A_+b)u-ysY%e&b zXZ<{B?T4OK?JSbvKlc~4kG8WshQH~X@Nw-djNw1#uXAs0XGskISqn1ex3d(6fAdPm zHSH{c;lKOMbA0X0z2Wcw!n@1bnR9I3vUc^JG3(H>XUrh?bi8}%J?ZC*z(1ZDw(Z|GU0~>EW@W`_0V1(Z=#& zzxiUA0q-|6DErMEvFOWA29GjD{-Hv)ppoE^oHmo1I$x3fu8J?UK^r!X3U;^)RkelR7jh zwv;_x*J*e1Sr{b~9^_TELMCQdUK!O@osbasMj@~Yy1Z49$EoUT0#**m!jw>D-~kmcIFTavT0dq z#|$}e@E|N#{8>=>0A(;3-q~)D$999^T|9v@9}Mr}43rh|@GcHP855dCIR#}?XkX)uMte6jZ2M=%_^?O<|SO4&V>hM zkjG|)k~lVZtkgO-n}pMv@i9qC#eK@9T)MZNnbYq&;DRk#y%Mix%@J?25K%&4Cj^w?G zALFU!z;>YyT+0^}-r=4mGl{;zG%`kUM8+tN#B>!KqZr*A5XEcRd5mJtc#Pt!;y+=G z5ld)e`7y@a4nD324TCbqaKt*s2&4RNS(9)YAo>mr#^U*nzVWG$lqP){_Um=5mwCOa z-${33eClt}Uu>9SZg`kd*M3W`3fuygqVV7)S7A_6c^Iay3fzp$cuFR+ua8aieRC6r zso5wQ&4ZTXVQMZe7^ddo0xvKh7apb-@D)Z_##hw3kgw5Us?>nMJWK^{Lao|8U(XDj zxeRz&?ig=wzTXMZGG+yC1R{@IH!uMYT~3dbqr7!D#l#0NDMy9@T@ZYz+`n~6LF~=DDJMR-sdCiIDl|uSyvdL?#L^}&CqC4vV$_JIib=;{C&h@c z$;*k2d{T_ks4685dRC=~sL6|oje}B*=u?%F3MH#jl%UCriH(X<3~N)Bk`fyheJOfe zy!W3nF0yH20OJe#9$P5JFTMa`L&dnr7eH*U7#H~hh|QMAMZN-L>*aBguK?MId0gZx zK(=Kb7x@bBz+KjhaWPwaysUI~dGUdfJ6UXCd@JfVFn^2od3Gnc2i4CfT|b|_jW}NM zIlc)sLFI>)4~ij|D`&6DRA(awh%eBCYHUn3F@YtD<>_%#XN#}ISf=xR!|*oIK{Xf; zhahrTjSSX^9f4SMO=>3#{%B-oFn&HFy#+r9u_F`k2gb`kzRJj9^x`UG2xAY{gRStv zhtf0Zj-A+KZq@2)Yb^c-OLOVwyXH9KGjX5E^22(`8^=R_Wp65iRxsfl|NoYM8) zgy4^1dHAL8{LW@c8I2SkM+_PUxgA>W=Q%a{&St?Ir1vHmQ16mY1wNL~S>#`jg+sJ$ zt?%Jd$7B-U!xc?4sTK4n6>Fmcy_OGL%_SOb(ht3X+Z4nd5G!mAaR=lhQySzR==AlA zg4_e~X5%QxJ<#b3XizVye#@ zDL0Ut^T)=5rM4wolpn|)za-;tZ+v!CU*!mL3sWCISbKO;t#SmpS$%^m&pYA4OOzwX zz5UYfYtr-6-cpVr_m;VT-!*u~L(|0(@LT$?Vg{^@{{#}+@fNN__oX;7vF$mf>$VsC zgtnKI9<;sSMcbZ%j&0AMlZdyy#U`NE?$S-d@>bixr2iQk5O3`C6+|tBy|B|)+?j=N zpE%S$+|Ta(Ms`qSl*m2y_UAUrE{Y5jxq07RaX@xbWSq$Tdfec0*-epwB6t7UAKoiF zDl$;y`syd<$*zhF6uGB9Hu(qHS&@MvcU|t8*|NLBEGi#uQ_ffe|X>y(g9rwM6Os{LVdPhk0paIK8fjltQNZK!gu$3{S<2+Od!It|8Lu!#9#7jZwcLvvWDN>xYUBYcnj{iw8pO^R!3Ez`&n~QVLkdoiF zar}?O;oA~Ua&u`*rJRMxWvPBC!f~suhhBbR6nUm1Zi9czq}Odlo*H~{Cj)RMMF6G2 z&ISwQBL(>dIzvN;33QFd94^o@4Fv?cS7YYU4XAyUs|YsW!p@A%mPyUPtN>JuoJ^XI zJU71GF;Vh{g02ER3GNele|K`;VR%zN)2)}hQM6L>GKDUm!cyP$QsxAL$$@UMAg!Bb;~k7FU%6l|r@I7m3@~TW$+ScA?vol$p@$_eSMthfr)X)O(+izd&~AZF z1XMwlv|r5V5omWRRne=IjTnD+XA#wCh!w9O8wHH-4Cvhc1H!egg9u9<9AAJimu|D0 zrb^GH>s_2)>*kaj-A;t(6UVb{92QGhhcK7+yFEy`1eo*JmjGw}`bQ)jj@+i^F_>GH zU6nI`{Y8`xKD{;$kCm_q`wjlS&r<+nHeYI}*vvpN3lP2ZIO?YBaX@9a+b=7V55ZZxLH=^W|K zp=Ji1CpB#BcRT!2hLlLOCw&J>$)L+5Z?Bu{%b+_1+5pVCfIbrF96*cAUi3o@I>qcw znM0*M_b2Y5W*-V@=r8USfQl4E%voP55oixFXMHKCA?BPAV=9P8v_!1yZ&&o_;NmYWMNGa zmKGQ~pP1f$-ZOid#c=4fNBSwhk*PGL5r-r__Z8B%j8yfln z(24Y|hW-g?4q-};-xm0oP3C+WCeQ{&c(7YD(ynrE|8LTA^ln)rNM>tyoOk! z#q_bl6b&w>?{pq(a4`j>nUn^Dv``>bW{~PN#2O6JdJVA#gLH+0M1w&p9><(14KAbi zG{hQQMxP0!w6u&Wj%Lga^qAvf^W+4bokF+hJl1X{xp~r|HD5*dXvk)4HLK_)4V_Ed z%o_SgLz%X1W-ZxeZo7fT0$N3bG_(Rx0~Kp%4WLGvry`Fn-!+`&oy+5hFH66=n)OEcGuAJ z3KH$Ep+;;qMYVf69lu;btliUTmO#orPp6MG#2Q52$&9Hq-$s`Sw1vL6U2nG2JsSEa zp!KvzLq7mIhd$7Btd~tx5aCj`VE%NQxrrJz)Z)C?JfE%;NXd5*Jt&aU*+sNpAf>a5 z=mQP0MP5R-MlMt7>=McpXb-W@E}=;RsWLC6dW9)EyOcI+h;?=;ZPO6z>{7Z%L87xu zY2In72Ci=_&1#C*x0QkdDV=SlezMZpK&-Q^bcR4%(7Lyom&c@i$9AuICGFIh+~2nm zwQ!lLZ~mN)Tf@*6+UU66{5iE~=v6@1(hdzBO%Itj&>I@M63~rgtQER`_qu*#-b4ch zQlsxpG((`hBGFCsnTELCZ>5TLOt+C9#yaO#+9{Bd;a2jW&UvccZ=)K4&OwjcW!^zI z=sa%QyC}$$aA3}LGjxwYTj+ep9`i1GMni7`x|crE&_vp2?x22WG2Iq?f_0yHAI;EE z0igS-QA3vidLTiA57IWtyPQ6=y=4B19@Lm~Y;Tyqp?5XJn%{|yN~uBgvWvzGq-v19tljjjhS;)plN-$n`*gEq z?WRErlK#G%ZqN|7!)_XNHe)KzcGI{7XqG^V&)rlfkm7SUouMJ-^C`MoVG5s5(H%OE z`Fx7rPmHNpx-z7%{n+wVEh@C?;Zmvn&=e)9%C*LOt})eXl(*r~ATG_M zUrCL{(j&U+S<1tl?l33-x|!H5n2A;MOnlM&b{F590HB&FSTEY za29rA-87G`K)4V!yD3Q5AzV&3Bdnl15Z2JW2v^em23y>45~dJ zccgs?hf)Ax9!*DBL}wyAmTo~mhevb<{*{m#fd-R`V*xa@O zwjs7*wmjRhw%IlV<(L@X?AXh7z#@2O$ps1A`0l3%=fYC3^OK5u9BGgz9b5Pr*pu&t zIy1pR7VgLN#y))??Dh7Aj9zSF@BRn1y z22DaAH)t|!(SXh1wi2BL3InVELWDtBrvV!pi!ee*BWwh7LG=x_#2JCqR}*EYWc!Q`J$QO76$5Sr-p0lD#HsSI;CvPXc|*gRCx5*(xT!i zg+;9~1Kb*n2|LNgm0>q8BpFt=eOT#8nyt8bntv^2ehlnPiqQ>F?q zZj1(|!9ZugFc-|CvUSZZp@#gKb7^JWVycgT70HhHH>i8)_+^ z)>>abr?MdwtyQB@Nqr<7qLV7?TSIJtG(9AiNHZ#%SC&L@iyf9SngLY0x~?YFG^MgR zM5?|JEo!WRGN>fd&{$U=YMLGjhnkR3Gr0w~Y^z$4RT`>lt*vFw;%PuXsjj&$A#HMV zbEu)Je%->l7AtBjxv8=y)KJ-UYP^(%l}!+AS`&nV5-b@}nrUF^q)<~c8YoT`&72ut z5ov0W)~l@V600N>ZslOjW$b>X=yR#2q1MJ|Yz*M(tj^D1j< za5{j>krRh>-_nZ6*A2{gszY&%{ane)n8afGO|9W-HelvT%o>GCd?hDl#}kwM~_cE7#@M)Yn4^&@j$Jgen_!Po@(?>lD9}>uV#RTG=2Xl~jfogj$wTd>Uw60hY zYGT7;<5fU;mAd9vw?vvKzgjL;%~6Gw)>YPqBh47TV@Xj<6GM+QmW7&D*TG3gDWciR zIfR;G`N}`S95KQG9b9ntY>qZzto3HM*0Bz(6@)F~F3qj5M`isHkDMEY!l6@>4mkM#N6dKWX0}Q42dx z+<~B+ItpXX*oqa^6of1AFN76|HGQt6HX|LI=8hl+UUIC(+KbYwtQ7rMQYG%hpv!|k z0zvDrx{k5Qb0y9N3 zAb3$>hG`hL5>OMub%M`qR%?7Np-yOOrCb(F3Bt6@gI{VsR8UrrAGpk41OCFmQ+2Z< z8>C$3Cj_N)84*iKjLovCGNN3fb3mph@W!<&E_`!WOE>rmBnBN2ZqCC7=s;lKlNUM>BfI| zs>?OlA*q8MPM0ZUWU~!2T{Z)MZoA9Igyvue|8u+SZlH67A$*q5!8C@)mFnT2+wD=sc<@kVFG-SAE*9GW z2Kdife*tPwNx^qNd!_0hSB8HmDHVAhPpZ>}(g!;{TJ*sVhu^SeWJt|!uG!@`A(9({ zLJk+1tQfa@$MNN7Wxbkm%mzQ!f@EKhhu>_tFU$)azzfQ-z>sYr9K;#=<&FKWTt8^s zb-#Z2^KCm<-uwBYnGd{l*4s}G8~CRo`%2gBTDs%h9$15*?G4PDB z*A}-=_I|v7+&Prna*6Aji+T-T`Q-NF-|M@t@66xd5`O5EJ9jO+b=B6%C)8Ya@=?PM zw#<9)XUjkOwD|q!+a7S|uUWc(%BHKm*YB?O9$&EV`e9$ZxZ&Qc5r==8_k7D4ncv<1 z;Z=8^{l_!se0t&D&9DDqa#nE0VYAMAHuJG1^B;S=`DO3PtyAdjena28@UiN$o3m}F zyfX5NXHU834-aK#+&lTHYu?=$bpGa=-`|>Z!#w6O__ZBdWjHI!K^6yI4zO8?$3QsXQ!VyB9AFb3 z4>oa-$w3YW*i^$gS`K<~(3b=LJer-~yJqK?E!p`ED==ha6mT#J0X|h}ItM#UXYYXF zbQ{hTK)85t@fgljT=17wkH1Dx!ovIxX<}|>zgV){?exR0QHGz~umHAkH+Q1m0bn2m z?1G_igp*;{fRM<&i%rJH1!89brh>--*qk{h1;)iGFe$ze4AA4jxqS~82h-xKoopTt zHYw0&4O>bIkl1vQnwrWesXze*U%;CoZ1$dQ4?qkvKyLgQZuKMq&g$|(#f64Vqgo`R5sO&)HB8js|)j?)NwW{Og1<3W47nF z())#MxQ+alDO_E(e+A~3Jke^7QQ*w1jT{R?;p#e~TpJBaR*%AnEfD;>@AM0$e{?}% z!6*bc+Taj@xKQxG%%?#}tVBY*a3j0q(!wzZCeA3jarE@fgTH(7>!+?edPK_=Z9jkW z;mX$*PO3cNlcIU=m@7~AmYo0Xm{-Efu3h(^MHm0`&epTtLpQy*&NCFUV7pC;qcj;KL6~|k?Zp^_D-&;{^Qlue{nkqScV@(zF`oH~q9D8BW z-yb;ck3xyp=Ph{H?1Jc}_4TtW>%!E~Tn#;hWHrMy2Zy7K%xy4ZP_`!cb!`}?8)}DMJ*@qYC3S=pVr^* zeEXV~udjLHiMne(*ff3DmwT^$qSx~`rVWdX{CLz|8(U6z`_3K9|8V~Is~60lxUFGt z;T_K$VeWYPtR=twCiUID)3@CI>ip{GoV7y01%_NEh847j85q7!%DJiq?w{vU1KKg@acYv+#5__pzeRhix= zZt3r?KYGZlH8YNQXy=YG52Otmf5KgF%$fV#_GRBh@>hOw_N6V6>RZ?LS^LaJxAFAm zzaQLn*{AjMZu#5I-|za%+SB$P_KU#ltb-RqUk+tG9ChsM&sY~b-@0G}>!bLg8Q-u@ z`oH9OnDuha-2T60-Speg@CVk<6vMokb+jweIF$e_@^7 zca`^8*4x$wwPx$&e*5UiZ=N7XbA9{83MXbxv_IuW_K3k2vC9KnP zKDaH+dVS@G$&ayaA1cc_hxL2+J1f3m9cPYya1`tL_}m}1v93SJ_;MHPd-tVxOkkZ4 zzdhx0)_de^^Ig_`V>ly)_5Y8fUY^EnaQL%_FXwjne8irm+!pUVaOJh!9)GI-%kf?W%p++O__eEAx; zS>~OgMci&9{HHDEwtHm%qocX~o_XozN4O2k?w&lK+wtm8FL{UC@{SqT{F&Rcdg-%I zahvYDaPs@yuFdaPui>`6`H}ly{a>EUZCr6wP6@Yj)7@X)$Zh@E_?iLS-hm<2 zL%GdAe(dZ&al7|jxA%T-`@FKI_qqMIS04V!?vxlcc`Y5$N<-+ke=_CI{G zc7OPbv*xz{^*526rn_pta^AM>nVX(!uTJ?z`uDr++m6o~IDJs|*woVoZfv&?{p*^y z0+$badQ#in&yC)>>)F03yRJKKR(j_4J+*^N9-cCB->z4lnl<9g&_A{xdDfE8{{GrA zcSrV>=LDypu(^LJKX&oc@Bdj1@UsWeRTYLAjJ7w4qd9 zPENy;jF)~hu`J`|CjW*B)k0ZnhOro|2WE8XCJ3~{zKy4S;Hd>zyaulAq@)(XDZt$& z^=}N8x6lDC#oZE?cFIAA5Evjo8WgAhw Z{dD~w(!dU^+fdbK?5=mR diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll deleted file mode 100644 index 3c6ea12c2c295db0b2c6c3ab95df5ea95502b55b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 40448 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 - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - The size, in bits, of the computed hash code. - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.xml deleted file mode 100644 index da4867ff..00000000 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1161 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - The size, in bits, of the computed hash code. - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.xml deleted file mode 100644 index da4867ff..00000000 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1161 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - The size, in bits, of the computed hash code. - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.xml deleted file mode 100644 index da4867ff..00000000 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1161 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - The size, in bits, of the computed hash code. - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/SshNet.Security.Cryptography.1.1.0.nupkg b/packages/SshNet.Security.Cryptography.1.1.0/SshNet.Security.Cryptography.1.1.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..1310cf24b157d53257bb1bf0c43d79472f2396ea GIT binary patch literal 182529 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

5=r9 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

U`$jj7VYbo3K7H6P{` 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 z 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 F^FQFDa_#^C diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/net40/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/net20/SshNet.Security.Cryptography.xml similarity index 99% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/net40/SshNet.Security.Cryptography.xml rename to packages/SshNet.Security.Cryptography.1.1.0/lib/net20/SshNet.Security.Cryptography.xml index da4867ff..ef8f0efe 100644 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/net40/SshNet.Security.Cryptography.xml +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/net20/SshNet.Security.Cryptography.xml @@ -214,7 +214,7 @@

- Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -285,7 +285,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -311,7 +311,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -337,7 +337,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -776,7 +776,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/net40/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.dll similarity index 62% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/net40/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.dll index a85897cdc1a0bef86a5e4e0097cbe2fe71351839..db4ea77673cd09ee8b9144c180b700cf14287836 100644 GIT binary patch delta 7908 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 E8-0ML5dZ)H delta 7812 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 rZ4Eqj%!VX)8vSmbW@m5cL4t}6T;7Ng diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml similarity index 99% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.xml rename to packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml index da4867ff..ef8f0efe 100644 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/netstandard1.3/SshNet.Security.Cryptography.xml +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml @@ -214,7 +214,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -285,7 +285,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -311,7 +311,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -337,7 +337,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -776,7 +776,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/net45/SshNet.Security.Cryptography.dll similarity index 63% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/wp8/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/net45/SshNet.Security.Cryptography.dll index 85abbb66e82b395bb7c930a7037db92b0d386d66..c8a845355445aad3b29dc3066eb4302a7ac134a0 100644 GIT binary patch delta 7846 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 - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -285,7 +285,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -311,7 +311,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -337,7 +337,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -776,7 +776,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll new file mode 100644 index 0000000000000000000000000000000000000000..2cea4205c36e08d0b25ca4029e4f08e78f688e6d GIT binary patch literal 39424 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 H(gObnuf7H< literal 0 HcmV?d00001 diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml similarity index 99% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.xml rename to packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml index 667cdd76..ec29c1a7 100644 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.xml +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml @@ -353,7 +353,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -424,7 +424,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -450,7 +450,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -476,7 +476,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -915,7 +915,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll new file mode 100644 index 0000000000000000000000000000000000000000..e26487c53feaf5b85011ad0a915b0ec3c5424885 GIT binary patch literal 37888 zcmeHwcVLud^8f6+H31DLvsxfQy_wZBoIQ89>5JoL&_2sl59+&7$cxq4iN>* zSrA3VdMXywI~4^H`>EK=dA9TPJlpA=N*_wSPEzPRTzAGFMTK6AmcK(nW@DOlT7 zS?{T?Y-k9!c&hxKrq%{eputl-r_@s)tnp_jCdLodtmjT4nrX3;e`@PVq1N7`!JY(5 z4$(%GxK!zJJ8|{k_ZWUe$&xpe++4u&t3L}7$}d`IfnJ5@Fe?8axoS{je{v(y9L_&R zbX|mruEpg&q8_;Hx`Ak5q_pdtCoH<)x&TizQDwLISGNFu?0h7s6I~&<`OibNB)h4( zsTzeM+hfQ$@Y{r+>8}vomEGj83j&d4WtrIqv=u+oUm?*X6DZk%Y*+lTYzEnBZW|gs ziYQJ>BgwAok%wu!`n%0&1D0)Mis4NmiVyZe(wvIqbfXO-*@C^1Zvo1HEK1F>Q>$j! zDVcRtLKDy%oBJ>mTiP)RP5l^5W6++K=dfEh2XYgda=EZC7Xr4I*?@O!xX7^D?7;*W z&uUAuCE4xXbRgQZ&^F6(F0N=I<$p;A!w9069PMll`-K^3JKkz@q$!~s5GpmtMkjX1 zE)&9bF|27&TU0c&H-hnK$?!ruN7iwM7nX}R`Uc@cj;tBhkxrwxNMZDC2Zk*x!|?V8 z2Ci*Dv1Q$Fcn1LHE`U6`3k+*J0*1{n+V~R8W>o}x60Gb+e>)7jDmcNgdNK4IhK<=e zm_3G2eAZx;gRdj20J3t4s-B@ZqN}X7;26{o7h5>U4_m-k=pSw|O-z=S7A#;CEd_et z5wG$_o1L+YU=qqSpxCK;N16kcI-EGcaI$qASsNkTAjqVUNA}VUpqt`hEfye)eTL%~ zfD|L>Moq@a@i4z5->_ymM7#uRnlsHIZsr8OgLVNQ;Uxv!p)q7t@(FS~Dqv3$SQUr{ z2_ps@ZCvGa7dV_-Di3Z`+Bn_i3Uv1MB{-o>-Wy1Ij7V45E_Z=Obh*p7x%&EgxD@NW zKWbg_#4xOiq6piH8%xu+a(F#ZENeORQslXbirgB+xN>A!(R6ev=8e^jMFy0X7#9Zbt@?Tf+@NaM^fyqVm8B4N7| zT4v=LZG08?%{oB=93=9=BwRV#46xO*R-*p~gO!yXLl|hs5T;id{Z;>A(y|%uQ{Mts2x2NU2Kcaw# z)l{xG+L-U=0HcNSjBT`Gl!t4V``Q@{W8^&AVH@E6sf;fhZG#-}IE*hQ>{k_Uh)qSP z5l$mbGD@aVUmI;0(l&QeF0`4=I<>KW?j%Q_hKj&;4fS-mJvD#?19pIsED1&%BCySw z=EYnCGQ>cev%dyl9h);l0~omQ`5p?A2w)kte+d!@yXfQzz; z9BJDeeSPtc{&`;-9?Os^we8%p;rZ3=&wts@?HZn+-uc}X?cA#2S-BuDxt-etAJ#1` zf%&jj&a~|^#uT(UkpBt#&PKD)KKdK>l73c}iARefhQo^C$MS@_D8Dy)h%wWo8@05$ z*ZS)2LRTQ}JLuFfZ*d!CZQ;$LVgB0U!77a^tne0{&8S*pwWWt3cQS+h!eDyU67-7n zS#rMav#iZln{jX(^Dr`MIFs&!yGpJfa_Purl^9mHyQ0c)d#q*1)GWywZdfafrM3#r z*&xAE_^D1F#7P9oC8u2hr8?~;cM@=0GMGXCKk z5alu^4DN)&dkY`)x#OZ-#)Kkz&s%)zaGyIV%4bYC?3=eedH<(Ackd{lF`=+WoRWOZ zYn{s?olx4l*oY+zYrX#C9dE=ChQ0Htf4=ALX^vxP{d^hS6)-^b0@nx$eECWYVR%T|2c2(=B@2hNaWB5|X6Ld{jGG73_h(%1 zjv)xG0t|><{hVeu?RzQ(@RQUpi&O zIWdIckuvAZTY{a-B0ccl$0L7=Aq@LN@5z=MV#p%Cxg*6jJBBbkQqDTF^t%|s@B}yJ zZ^u0nLl}04hYr4;6-yX)&MhyW`-`Jov#tv7Sw;fXdltQ=86qW1AV5}s&vjUW@>=hReM|-F&HI?4pfc}c%DLWX zV`ia!jLNHh%rI_5*J5GJAoei|BfO7^Zo{;X*$Any^h|O0mJJ6Mp3Ix5cI|`+aG%wcS40##qAA*i%C?f=6$!>FCnWIrh2$-xuFB?iu zJU9c)=(W9=*Jv9K5?R}G=09HBGqGFN_N)R9ZG^Adp@~v$+?+efs&{At^|Z1`eNk>UC3 z{ezFUbN@gNwwBuAu^l2iJceY4S7NpCz6bWP>3vUstF6*rnKj&sP0vz0Ha!{G`z(^6&*@mUs zQsayiyOH8Zai+MuRWJ%RM=TfSAS_2JQIHbn1Gf|>rWyvpC5362#7uzjjpeKmxO~jj z5h8FHDK5}3iJ1VA50ilqIDL>P#U3Ky)=`cg#cTZ(ZB!d)w_cX?=ja|Xd&=~Vws1v%UF)zd2i9bhY-Xnzi zt$SMYS~S#g-P4=b5CeaX-aP$k%XU+5tbIeK?OtE=LZP$Hb{Kq8urx9lc%Ag|1=r6F zQP_O(M#!0Z7??Nt+`xn{YcCTB1 zP(q+aX;(VSqD=6WZ*;9Quk=g=U1%(8M?u$)(Ur!$92I;$NV`;+m$-^RManKU=4G>) zplg+RF|H_7sO(B-K3@@hJwOlBIUMP$Bcp+R^~yD8Ee;LQ7(u{9#hoowT}J{FmGrrg z={|`O4@_iiXrbyxFf@_Lfr+B)dhRpPv7ae29p1ZV5^*@8)4?vrJZNf-yI8fRM`rhI zB0D*AYcT?)sWpx?sx>|L#+W5cWD;(or0kweIMgb#u4hV9a~!P{neMo5+Jw(cgiiNB z_iQ4^F{(K|*>=w;9557_w&jsFQFDnuGTPX;hQ2hbJT$*`9Ar!cBAlX7!gUyBOa$yt z3SaqCCqc$U!4W_xl+`+lF(z#GAjMy6eOQb+LS-5BLZJqImnyT8rWBNeD-ETcwHPLWSYpN!xfztE=GJX({X$dIz4N} zhz}+*wzW{{r~=J8+d-MA#NbNEt~XL}O}MwC zlkni>!%QTVYY zPZI@?YDJ(%^fKbHPhM5}Rfo#^G8%pyw#w=48O7rM7qjx-cnndDwD+J2# zx>lJ-tPpgha^&#IH2<@wzVq+^+~nwbfoUR>{#JCl|6)W-GaYZH6`h_7VuVXG9h+Lw z>F69IJecU%^-9BRNnW4`+0QZw2WoR;-7^SBJF{lpvj@iuq3ZPT zRv&MfwsY)PpRTMwJ#^66NsKX3uxvu1tlm+CF=4YK3AVOchx3RDpGUuvr^BVH4yq;s z_8mo_e5b>S#Dp(#-b~Q7#xgq#iSn2(ROS(GZlL3!Y7&Wk#KgYiplZUGL9JSdv05+@ zuwy8E6&kytGLK|)6J6*m(bwEWmrC>C6$0f(T`SG;R<)qwZI>O*16Bx>>m9Ci2UrqqasY`>96CEV#38>kG0)0VZu)|)5D|4ky>F;D_Ofx3f>U9 z9oUsp7`e)-U8;mWR~GFsI+`@X_|zx%U2DXB+xg6AV#=GkZuS!*roOe=rA`=aTGXzT z;>f6X4c*X+@2;u=71dL5SbxhMeIM=&syq5AE+6Kzc6kax-Py;jdOQ&%&myQB{Fo@5 zzIJ&cK|N-Y;_%_QAbBn!u3a8w(2pmi#`6O~eCIzU9uEY?~6g9m%JrLA@ z)429gK;(B8_!@p7hyn8hK~fodAV`2C9|)3S{Xh`s`GKIh7iRKH3}XRCKM-`Bl(a$s zsMOK3Kr2yYeirC>5SX6@TE+E78}kW03#9VuS)lREU)SP+5eD%bg~A9w3l!ak=~PjlGhvLK_O*Hex_=z>3JBjLRve^r=Evl z1B9N3iM-#yg6IcfSPcCj3=5$jgkcf%gD~7a9)w|4)q^msmNWdS14Hs44Eogkt^+p= zXJ<*|xgXBRb3dF3b&Nds!3dFi1i|UfsB)&)EJ?t# z0RyV=ya0&!(S;a9i4M>>KojqZ8&DO;6!Pps43ZvToB{42LX)lmRW7EICm3Q-CB%U! z4m5aAV?dRYN#qfR7$os7khnmC7Jsq9FE;qa4~`rQYdVStavvZ@JcvQmSv-hA5+feO zpz16h#31P`9>gH&JSN5<`o#uVgmyA7#4y`0e&F-{pWEQ{j^cqF&&G%cF^D?zgBT<+ zY!HL0vv?4Lq_cPsgQW9#5QFF!8+0BIVwmk0KZqF*Vp#6KaV&HguV33+^^7k@JcvQm z*;t4{62lK-P<3X57$lv=gBT>8$AcI|zu2Jjco4&EzxYASco4&K-5Lux2TQ;DFOYInq(*4tR@DPIc7r1D`&cPj*sWe1n zFsUv)#U~~BWXwld+YRd$cY2j!?duzsY}vx!jR@uOMTt;$N!C61R)o9<#-EEAmTZJR z6rlk1`3RNAM-DsI5irhNih=YvVUh7TqgFds}xC6tuUt_X1C!K4)HgGtWw!DOL2 zn4AhQ`e1Uplw80Z`+NAqPMw@jZUTn+d~ycp%;%FAalO&T>_X?0DzDBbPvmBFEe^IA z#QCJc2%k?zw_!S;d?|E3=?T57$P6OqlT0Y*lbkWyST;VNoQA79pS)PgS^LQOq(JI? zQdLhxHO?nD3vM9;{WVa;K!ye;F@W<)g*RECWDOMy)LTPS1WMOXi9iDt6gkNh(?dT# z%e)y^2cPlbTPV8=j_b8pgM? z+=l14zt7p(&QcqmweyqawX?{EXVWtK)$J^=;ko_Iv)%11tl{bR{Cg+2v!pnTWb>&r zPc~KL%#$Guici${OJ+f4r<_Z&fEbr7v7C8wM$SAr6OvfYJQ*|1%Pxavq}FI-efi9j zuUTRb^O+~NsX7#Ao)?0U&pcT`IrHR41d#0;a2IpFm_eN8XB z%zG)fui-&um*MPD;kbLE@)A@=N^t7w+ny4Kun?CL=bo6m%V=YZ6sm`=iS6XWP*n=2sc=OLDZx?Psb7#&(b&4x22y%E? z5Vuc!i78G#?A*#SrQ&5l2~Q53OX4-dPAMHO+%oCGXS8@>OOZM>sa?(|JEgQcarY%b zy(sC>q;^e;W6`+I+q60OIR&K?Ub0lJLMIkjK2g(Io6r#Vt)Q$jhY%(zI+rNW86gzJ z-CGAM1Y-zY4@Kt`)jO3H`r!ty9qQn1GoedRbPoN7XlE@#J@f+Jf`cK1E?&`v?mT5o z9RAaxLvT-tCq6Yam7`#SlF_OB1rwAEP~|q5pk$0H@8Jnb#;I~5^oJU&%9qfwYP>3! zf`>$n+0+D{&BU1#Fq~dpZjp6Q(iOZdUOrNSHm4>@tjWLKb>a#_a zzO0*!bX4;6=1xQ=Rj|^Ki`Qtjib~v70OqO2AQbmw%wEVOaecp<%B-b^I|Xo0u1G~D zQCP&Irb^F9!(Lnhp}a%z4)8j5e{~aWDBna|2vE;e8R|n}CrQbb7zGFr9lTF}HEPUr zln?mkIcgi%8*R)cG)Jktnxo2?y{<(dVi03jVT9+X=r&}I!q>J;GNI9M3>S`w<%^kf zT06_5VmUL7#B$XHVtHEoB1TCVkz};7`p&fF*XnO-F^InVvwRN?ZbOM2bG_H1F{6#! z;V+T3aYLaO_*qh!6ggwGapRa25eu$i*t;ERD9%P=IEw<;Wn_uroRJvLnUFCghBIcG zmrbfQ0~yP~F`Ta<-jVxO(xGjvA!7I~AiNeN3`z{=jE>k*uexm3pnD0j|zNUu!+nC!bc*iW`uC(5=IgTyWkU< z85AF$TtX7zcAirhabWC%Ph_4@eAGMnS|S@hLdF(iZDaF^%o>V~nmiPnM9dq)MwE@s zCp?J=8)Z?&r3dV+xQME;*@UMQVI%fbToPbp#YHI^n@xCv5jJd1#RX3_z%7uv<0tO^ zw@fkYl9&tlg0aM&iK&1ufY?DX#qb3X`zfXvz5rr(cxh8 zVwKUCYsXgMV}76=gvsbs!#xTpsVMJ<>jW+z$deR4=T}pYV09C`(LkoZPqOk|!+u26 zlVgt6dn;F4QOTM32Dhim(Xa$l+}sO!A{+K%C2XRmI3DMbZQuPsZ!hN}Z2R~c-u5wI z-u6l5XrPBN^B9Qwz^35nZ6D{cpIc|aelE$a@B3S68DvILiaST|qr6vvjf!m8`P?i3 zyAL)y3SjTy$1fDb-s5nmYlxi(pRUvp`;NoyRgm7^q~;j%dcf9y?S!Jik`? zZDvXz-?H;&+_zczZRX7v{ZNyb-Q#WLx0yH2`Ek#nX}hP2-|{ChFK3g5_uTscwVw*1 z*`$088=nEQ@uf0kd;yL$z7%KhXH$DCru{wq6<)ng*$}dO;s3DRW#~HGIl51H#5&w# zyX+I!(+__m+eir{naAJ!%m&#?N+ih~@%^Pg$#zmgN#@rDgDPZ8DX}E;rL#W1L$;L? zOETScCybD-rNolV6^|7CQ?{29OETAFo|!6JOqMK*CY8>ZWMPlQUl06Nj?T`>&dyM5@hJLi7dagCf~1RV zobMs&FiFQrdA+0?B`vgN0Vm0NDY)&Dl6)7JR2W%~c*=Er;EJaLqz?L{!7W~gatGZZ z=`siBZx{S+l3yq3J(5;Ax%NWg|1S&Y-zQGrlQh-E+*SymC8%W`Ul0|!@7BROj~a(u zQ;@gNdO+V<4!LH*eo26nX)T~0I3XA$ked|b5$FsJ4HoDwjX6x9S`B#xx?5w8pzF~3 zXy+jppE_id#ga^C19Kjrv8YMLmimy(g)gd}Aaz4PH;*#qtM$pW-@$c*X`$4ule$sj zLCN%%)MZnHw0E!YoFHEwPNq!Zc>-+^Z6AWRE_~Paa=~07nB{c4wEh#g%%oH3ZmHWX zEu2aZNZn^rS3!@6!@L0tPN60AIHe-D1-~+?(hwV0K^7Wk)EXArYFmzUlCuG6ft~Zk zNHggHTazx&q=1vlk8^QJi>npsHsbss3#TQLwjs@=?XJ}*sRZV{b(4WJZ{5R^jzaCc zbu%QLDkYCenkyxF#%Dhr)2 zX4ivH>$Rxm7CVw8 z!ap`23q2w{_e=V0mz;CSZLBqH(C%!ceJz|8O4=&vMoE7s>0U{nLdw#f+o7~OiF-EF z(rPeg#xYAC$>&=>qm4$srIa=sb3Je<`Z%uLJ`sL-hJq{~+P8ulgM;fVFW9d!9CWFM zer>hwt4(4p@v?Ff<7=q_Bh16FsA(;;|?PN z9fD*@lsK5#Y)C&1@g_;Jr2UC|!6k|MNZkP!x0ghN1X>Tw-9{3fDA3t}9x{4Tc^KMn z^rAXV_ke36^`;gLJ?bh4)UF_6$@u6yBd4@9GdV11zlQEEv7wBBbS&n!(Jq$f(WROpw{VvwlL*?PR zazN&~Oj>TL%cRv|=s9C>6y{JmFI-oSIqtGB^qes)3iBwsF>&||JtP9Le}*CPmk7kY5`nl^a#RC!z|Ni= zf!LGBgzMOo$I_p|ayn=neJ_ymrEz2*#>lGQ$59^*aSP*Vus{dIL&noFx{keIJk1h_ zd(%M^wC;-M1Z~{|F4i^zv9=SaMe}5haDQevw|;=Qy+XQ0L+p`-v`ZlNEQWH9V$AjQ zhVimdNSib?+j!0>qJIdqg(e$s7?Y{Lmoc|c!1bO{LL)WQ&-mDwMgis~TdBPNEMKrdaSK`cl`i z1y7>@-jWCAf?|0R3(tI*##67NZITHTB{+}VKZ$~m}0ZdbfvCikK9ZT z2&8ykMDHq0nR70RvRMRTn_WboXr4T#FQS$eETdpcF+t3rLS@hwq8%w0;$>edfFtA@`CFrt%uuDk zp=SZzL1$^`1j@JWq8%E#4$$57n1*ry-9xWyXfvRDqwIMfeJOR9P!D6Q^#O9N=GM2+ zVoRa*cTxTDFpW}mVx>J)B9QWsJya%;^13~=R3PPbduXMG*z5Mv*$Pv)7k| z(w(YK{A?fX))3Df5s3Y4A3dzOFwcFIvxcQsy|RxU5=cq5j~>#eYAsY}=k#vi7_?DnZ?JL6WU1xUpm(MG!Em`MvCuVA zl4meZ0a7a+gEYkR2I0)KAxxEzqy{OTkrIovb!7R^DLGP?|I9K+^6AW0TSZ4s4H_m| zFBY480P9(4gp^z>wfh`wjVmO76;dm0L;9bV{5%OmvOUs?gh~suoGL#Q=S5Z;j?_Z` zT_rzHa_rp2V#>Dvnf1;TPtFtFxfcxL5-X{apDRynZf0q_YcXZpjz*&D7c)<TZ+o4Lzk1SD|s#QU^{2PjklO9Pl(} zGUZA-PSPStr%O6d(lSXaB@IY=8qz+rM$+|Caw}2?{fcfg`qOXeOv8;ifjK`-R~bX- zCCR@j>HCs?N(1Av=m+X;KMqt(d!@&~ZrD(L|)@3)O>2x(oCy=UO0U;xr=oTM0Z3~&vc2xKD7 zg{2Mb@`oXv2nvG=F;WdGg8vxs?@>q>fx^HJG#9B49%WDfeqd0Ljz!uCY6G5dJkqt; zu^V&_I2qWF6d^qiUT4s6aC&RNN2VgZho&RF7hZ(f9w);F&Uoh_-9z(`J_^q~iVAlU z#!%r+e3!wtj$IH=h(Asb;+&XQJp{eg-_vvfd{dR_B1D7F5ck=0)8Sv~oUN!RZK-St zR2MZhRj!%d5NKJjrqN#-INd*?U~~>mn^iP<{`9$1W)%3) zDHRKX6$_^~v@j5;ozhSfsBBme)Fq`j85o_PpL^_>;{36ba`Q_{rsN)bY)Nr(K>>ux z8CQ}!X-pnOD=ChwzBh5exviLB%h|`Q&~O`QIID-scbZeRQaspF;p^!rj0=fex3G5-k5?AAITN~A0@})ax6_7 zi_2IVKPy<%TIWB3#?NgEtgLMDPp@yR^VjcV*rh=4Al6WCRH~3Nww#vg^e}P zo+bzD8v}Lzrm6l0e-jF7idt~*uc{SQ#r~?++FF(@QU>%zf#yI|Sy6MdzrLz&&4NIS z88uwoR9WM%uWVWo;j*Bz35u2A-(>c~2&Re)=~TxOeN3uAjlHHMGvr<{)XC?WmFYt(K!ypvnrRS}|)Tvksi zh%5+(!)|ye`U&aZ5!^&eR`8xi8j z(nv{of?{n#(SXB4?%@TPH4ZOANRBE(G>(Ef%8V(9Dw-Yzi7SR%4T$r#E?w$xVuxX` zQ$R(Px@K3m1e++kS}s-1AyX9xDr*~p&6tS8MS84ci-!gqOZ`nN1Bk96icqy0)&8b% zy$Wn_Gt31*hZH=n!gL+?Fs6%o41kru(~PJ2>lzWGsHkRnYqPMB8Ms+@B_>8u2t%UT z--00mRdrtJt$~W5LYN=K6y%@jU)o}tQWcr-#hikLNR#G-f2VvU&XFrtQ)FDq3WX|p zogyO#o=9lAg0GkyN|yzjS`g-I7%ug<@MQ&O)wI%~+A+PJWQcIg;{&a}0o>Pbgj_B7 zN8MX#DgN^l4k}IMbELExstFfb@#40mIzhzjzHDjkR7xY2s8Ni-McwssA zUE$4J?|lBJ!g~s@%R2Y|d1J}uu~=MI4{qQflaj(<5+{buL%mKxMG}4kjY0N!vRiuj zUHIQ+b6N)3ZDg?w1kxb8!-?uab~`?dHOLNZm&0itWOuokqZG#j80@RK%E(D|acvL3nKduDdIM=R;6>C#ojX!R^ z2Mckst;0$c3s;9h#PIx5tOI2iZlTm6U+zf1Y~8?u?Z3VM^D7=+cE{%nr{DYH+IJow zI^f-mXNy12+I`h&6LS_^JM@be*58qmHT<&?&$XP9{Qb=zUw->pe>ijYXB!V}di|}U6yLPL zGtYZE`H`}DkG#`-FzuAqN%T(okPkLKQeApOs^!#IMqc{#slRz^cXHAlMNeG)-UgrJ zcUQl>v+s46IbZl{*u3S}Z#wDCMTO7S+`i?RAv?U8?VuA{4|p-g_AT+aCU>oFFE1c+BRP0+jzNe<2&HCWKQ~Wg3}#5W6TLZYGmuf z3IDSTHvaB~jbC=R@tbgP3{>zPPg@}p{1Z4<2b{yv%WF7Xh9e#jE^)ZT8IA;8@Jp$| zZ&|#@4mWbi&jUZ=yu$-W8f15Rthg%2>g9C->g5IO^uRZeao`G&z1Qv}tA$x$9|s3< zkd^&}YvP%S)Oe)EBQ-!^Z*!0l#|%NtSGagw95%QZ8-^u59!TtTC{0LUlmwuFf-g2N z#(~vKE|-P941XECds<+morD=~cCaBln=Dw?6kOG80Ump%;PuO%J!JucQ$tN?}|BhZk%HsI=6JoJ15^3ANQx(|9bnbfm7E0={K7i z=8t&$go_4G*cq3;@Wc1Mc9m7EzO3f{*7sWu*}i(N=##HLe6`@C#6M&uopI$G>q}qj zGbPaPt84C#8@cuJ=Qah#Pq`%Lz|7;WskrAi&z)Pk#WLYaW8U6zxB9n#n{_a?^34Lz z#(V#M>xEz4{Z9Lkdv@P+&hKA3t>BurGFRRo+7JHulPSLU=(#6TG3 zxf}31hhtW8>B8mh&O0vef8y@U*}whiTJK=C+2rHOYy2zyb-_kn*_505c};n9Q+0W) zeq>kS-A#E_prKrMMR|k2rCGZloGvzfV@(yy`hWeGyfY#}7Uw+?*qj?^!oy(%R4=Zp zn^hTTp!()&*ugJrPo_9D3_OyrIA-IdEyc&4_QF3O+r9Jc-JhPkZ_&7~Q@$>{@vMnk zUp;l;?N{99e8Y0`*}e9hlRNbB_8tpcPTAA+)7|f`yV>#1)h%CNy?1Zm>W|Kyy64LS z*X-^2+>RbYgCjp3b=!uP8SmV>tNg9=e^@zx-U(OKAIQDssiUmBo?Kh@=r;-P9hkc1 z=2z!cKjWx9`sm*0#6NJ<*vtXh|EeE3D>ZR!>4N5X|3mT1S7txGZ~ZwVo3`%wvGuux7CYZhKi?c3j30Ci1-Fx*@8(hYdn|?gB=i<-m=HB?-4L|Jp+v?K} z48GI*I@{oR|CdA94#yln>#uB!hu{9ydbY>d-P68doAi6pem~pg>N)-HV%wyzuYZf} zGs&>tz&6?wY@EV&+H}uHv)NW3+;`|zwpZ|1ZGU5%-FRH|lD^!-_TG2VEfd)0!)}hhgzX+Y%laPMzOf-Gp6&my zV-A*Z9}ItbcscjO=UMv~b6@=N-pj7x{&=_gt_!$NZn4G9=zu@ z?%#ji^W`br$4idsJDK~r>GrR7a9{s*Tup!OZ*NBR5bpC&A35t??)N@x4&1|iKcckh zL+<}=mBat?`xB0O#<}mY%qJf__oa-_-h2MF_P74B`lW_1*3N1F`|pB%n{KQ9%5l>b zPhI~+dv*Msi9hVIT`@6bz|?`MV-ijqu%X>H7To(*_9 z(h_-ondlMQmp`eKW1gv0j<0yrRQ{NyTKMP!T#E6tfNLf8D<#;i)M2+W9lIeMi3rkA zId@)w+Deo*qrMV5pa5zcG?QJn8+n-qnOcCwJE__ZIIR<$9Gt3}3a?NX<4hj+ ztokg4Y`C$y!iTE3G$TR~5jW8xLe_1zvSnj%Fzf0?UK*{@Jk50+DSb z?#6_8H;VjgP+KYOFv5IkuNqv5Hc=jMLl!7TO*2|xeOQKwzNNCen~nMwv{j00HKbv@ z7RbwYoH~+wO$QRPz1XHTNSly)aJL~_Y@*~2$+8G-G@;dq42&1TtrGijkF^M11Gv?h zwER!y&4xsE_>cd}X&`Jf6Z~t1JNH&2v}LVp(JR;yOAkhudFWQ?6tS@f7S4g(Ik>~3 za#*(FUJZ|j2yf+Syl1W#yQ~mzU@3@}i>`Q*T-s$%V_idbVu(G6&?~$H|M`7n)_F1R z8{yd!v=xLUTE*MUzVn~9!Fr6x-N3_nAKuH6J|2aU!roR1+Y#PkaDlc68uD30J?iSv m6CRA - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -285,7 +285,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -311,7 +311,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -337,7 +337,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -776,7 +776,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll similarity index 60% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll index a1b0b394dcfe365a7077c6d795c281416e2c4c7c..ad8c8a6ab60ebe42015923813af1df4f90a6739b 100644 GIT binary patch delta 8195 zcmcgx3vg6rmj3>~yKi?x0v!S&1VR#?ZGeyn$Qw~!K|u&15af+GJS79+9q}fDfC7PV zff-rY0Y-!{Drx`~kqt4lIIJQ_SXXNuoE^utu!fmpYgZU&-E+==(@83f>rT~fSLN&f zJLml8bPq?CpCSt=}*IlPo4y-(*foD>Dj&&*UKd$_H~o|j*Enh3N8+ylR(c2R36t7NzfbFeE6&qiC*vwnUF0F#?k&uB zK|6AwTdreSdVHo2ohUAmI9>3rGtBpi`q*h_ZF%q%ZS;g&u(tuaP?$Fy$22Lmn08Q% z!m0)~!d#n&bojFKwe?W*57>l5`zc&OJLf@vmD=a{0`s~QH6@8ZAxvdchSVajKglJr zOxg>n*b{hMC40R3%07>`b-r#tmluioIwd5lHu<_DvB|EWy6n6hUoTvmgsZSx{+Dv@ z1UprD6LzPO&ECHCYdVEero0X(-i@_O+f8^5~*`a?pK{FCp`bZugNvc%Sn^ z?y#hWR;2x!4yt%{Zs)F0zi67WLHf?mkN3w}!7v*I*-C8Mr(1zID?cXAit~rrJkC!E zy7pF_FCg{-+F;C`f0@)&-0}vi*3cK{^^2iD5Om#oDU z$g>`{&6`#IICf?3z+p z#?IsxJ=B&whAc$4zOyrh%Pi#9Yb&H1GBgz5CRw1<@C z&R?dqZJA7`XYo`zc8qC=lG0!hP;#n zbfl9#u`RGQNbB6?%N8t|SIFo73v?Czj{J7a%f*2%K!{`=N9BzkPT#K*Z|QXsX5JfH zLzLpeOMj_O-poGs2#a>n$3oECI$&X|U~A8p{^sZ#VEO%?6IK%hJ>U8*d_!vsg(2#4ewIW8k4b><6idDU<8{F$0rs|5{LCUP7k5c&R8T0U&U~n62S?Ldp#*ja z|EXpN=h7Xh83{tLiN(N=WML^VELGT(F6$udxNF&2*gThog}vrlcEbS*|8xIrI$VBa zK&cScljSU8{YVqCv4WHV1TaLD9ckk%q{%%zgs|v3AWw9~qU(YAyb(i0mw_b`utJ;; zmU}@6&xmdaHb}j{rg{Syi#=kwNGzw}SK`HqH4iDBAOsLP9$Fm_7}+{LX&k)alDTMH%^h0Q0PIs6gCUC zmR&;yR}iM5ujX{Qdh%nFqnzR`m`9kT7>5b2Cgh44lVv?put;zlA=kZ-v>ftoski~i z{}1`GIlw#Ov|8}u|L8gkDSDyuQhiGZTPwz)f-3}{6Fe<=PVfRDr@ORqx;BXpgO6^S znx)t^8`aOf{@RSs{lPrdOWnW!cTs6nE zD0@@2z+!h_VsM>miRCU!4OS9cXBarOR@fq}8k|}y91vz#gL6wnTt`l*8eDxMdJ8K- z6*a1j>$C*zeU&N+b6s6O3egs+op@gf!ofYN9R>>9NQqXeWQ>loh-!~~VbuXHHx<*2 z&KA?u2Ff%njBc!?!C4(;5!IoAWhZQk>MB(y?2fXC>fFGxtK1<0lUi52?poS4{)h_W zoKTZnIxa-rRH}4bi?WF7*1(b;;N@ecq>k~F)G?ltI>tj9Wxg&p9ho}HN2ZSPfyt~5 z;p2I(V?57&qB@@Ee)uw)sD=LcR+yQm{_u5XV{`2Lqm|1BTJ}0M2pxn*WK0I3r>o>i z7=*FHxNQ~&yVV<~gWU#40$gt$<9Y{Ux$Bcl8Vt}Q2oRB38;YYYqp`FxRGv?GgxXUt zh9a{oo0i}!{ec>atuC9cBkBSChp;kC&{xzjB!$_s4Ap^8)kt)ASsQ&_W#c}VwI%j2 zhPo`7*drL_vJ_%=4#o>DK?XfSOvK?Vc53RKh&P3qdMDz%Fw?||sBsw|rpfrNv6LQ8 z#!XkpJ)Df#d+U7Wqqi{QGv98|#QZ4ZCgx+1F_kkm9~WH40jFX{FLr7U+EmOJRs!zR zR9tb{4c}L4I?$UfOQ>t#s2S+wGVbqe*u^g8=FdS3nW++_>3>&q(8*=b;EtM$ZZ2!7 z?x=a_5On(dUzAe-=qY&4GnFbf)_b%gl zSK^kjlm@Q^=;vkalpWU6|yJM^`D!_Q@RRQ#f_QLwb(S- z==kEf7CVHQAzh1h^rO0VNY`Su%eeVP^#)Ptb@fJ1>0+D^%QAZWS9(3F^ZEWmM}}Lo z5qB1_(=yZ`pf{q!LcI)m13*0l&+QHc~{3{ zS&BD^QGDZcJ3cq2as%4lplx-G+qND5<~rrBZO8IOoT%yAPUI{$jJviI(}bC>?L_Da z)|pd#rzzK_dM{ADPPE?dRdc-?i(ON0>CbW0W!$H|xbRbUQ-;@lO7F!VT;{Qq-jBqk zM%Ndu^#NqMY&Wrkc*wBC&;0H5Av`9`Hh1Gg*ecXa!XYFqV>jmHI*e3dri#PZAZ!DE zM-?8%RaeKS(_v)Fk1=x^zKF%b*5igRRUgGJSI0#hL-$o2p~S{I`n7Tli-eZpl&_0E zh7~UJTV3?ac-mz{&_ln9gDyKj>@`%nER)#l_$QZ@602y?(G$2SItMZOUi}6Ft2ulb z>_^oAeL6aNd??PKhfzwS&SIo6GbLv+MVJ}Av-pWHGkRyS(q%k)=dj*b%IKZL4p+yc zcMh)@UEn>N2C51tUCQTZ9phoE!Wq{MJFPw1c(A)LGiAGRe&u64Tq7jTM zl6XOS)U(O7mKvwE%s8Fknr^io&=J(KaRFv|qT2|*`$w=j%C@QZ0D6f_r#9(E=wBmS zSP8P|;o~A^2{Vtq_C*v3HP5{lc^7@E<@xm=4I#!g(fbSeMC3{LQiG@2ODGaAksv>Y zUcxq)@nh&E954~&+43V?5@yc3%Y6M)IN|44&%X@ti{MWQy{IIK565ZUSgY_MX%&w8 z7+cU!YmFPSx6;d!Bcf&07)n|XYNB!@Q8+DgLSuLJr{Tx+gKZQHHcqASgxxC>mZ9nS!)(*| z;p0?4K>c<7)ZdX_HkO!Ljkf-p6SW&&I{w-K8o9abFlw+n55AO;KcSb5wO5YD)tgJr zQJ+Sb_Kl@?3uEaQ_E@T-#!v6R;^@nw_whCUCb)+%ge<}Sf)5Ce7R(WxA~;)cf#6cY zR#+ogB9dnX%Ly&I$G@eM@D{e|6uR-U|MyX@JL0me`~S0ieIfWYo(iVpHpcq~&^F%u zJYBOb#3>zo9&C9U2QiFpJ@2D~vwg+>Ia727;xUJ?ElLPG;yJ=@xK7v$O*|PGh)lv^ z7)VI(+6Z%D6Hdi5gpXkd;UbX~3KroYN!H^P&oIvx#CV<3m8JHlzA-c~7ri-ze-!li zcpVfp@_|9NF_Is~#(wJiZ>+s&OUSz@{$J#O^tRzzO~pH`JX+@l7^z~X*Xm35OBg|e z^%_PIzD}=UH7cmp8gJ5&(V)`1WR0`PA^ZnwzNQzrd4$!NOn9DN&1!m{no9T{y$06w zLU$$&^T&i;(Y+k>qp7!jP5VW2+f>-AF}%r z>x=Au^i{F6=m?^OvoLcyYr)x zX4zAQjQrU|a?i_t}7I@!e6jH=hJ*3sTF{5_F)vV$X9SpVMr|kk}2>i`vfy zXUdMA!P<5yr)A$2lY09`&y*HJ%eS=G7mk!4of5a?2=FNAs0MC%%Tp4Xd;l~d z-uGpoos*&;cBZMWYLrt(c+06&Q`=O~6h6k#pN0>o*8rudfO4`n_ph3y2P@UqdEPTu zB|3lcq=ec5jZ!=4Vhix5zOKW!oD}cGgd2dB+EIJLi9GnW)&)15wO%LfCQ)7NA=`(W zo8N-=$&d@|pxH)?ps0)R8!y%?^lS^p^ ztxWo%S$DCz@e#H3{Pa|h-<~7pA(`nFHOU=T2N!8u2 zTggBd=aH(%e`w1e-p6yo`<=IPzC->Jax>J+&V<~=g#EnsZe2WuER*7TiA_;%IEmLt zicbi3AE%3RNf!#%{kERAJABBwnA=YM*!kz&MNJNpWyl-yg{<(4&I?mIbn^#8{=B9k zzZE_}D$5@TSI}=>UV=Yl1;cC}WP7phmc%w>>#sAiLcV|)1<1;HO!fIgzP!e=gqZV$ zI(uKp>lb@}AV}ujr@AgFo>0`OH)x3s2g5fqx z$J;h9%tN|vyl4ZU8DBS^FkQix_K@<3lQKQAMF+aVN@vh%N#*N+b%ke~Nz+HwUkx)! zNms*!}{V(5?HOmhlNaJ(!nLPn|SG5yKIuM)-KBumh7_0!ouOh&QE71IiqH* z^_#UXI&aO0S$j5_(b~x~Q|>N-_K0T#ABD6>Dhwr0wbE>~2F3wFNpo1H{v|xg<#A?5CbwxO71w zom#A+jqwZe+bK62tG-1xBS~ zXPpp9mS?HY!qNcCC+f*o9L8H-TU+?G<|Vh0$ihCs!xoP}7SrF!_=4cS3m*2fcC#$- zp5pQE!T6rw!~lDnE`D-I%gMbeIVvcWQe|Gz!-HdKtWX9!9=}z?gY)U85=Vk~6cB3y zKiUgRf?>(R*0`*ruoqm*F2ZKGEG+DVYuOzYwEQana5`Onq(P~86q02=u?*70+sGwl z009gYWha`Lj}*Br$0H!Rj>r{Vspxv(ah`|{qD#Y4S@1=1Iz%@8czjoML-DNSdzA7G zAQQXAa*kNe#8L5Lk08?tn1z#~d`*^^jn_rlQ*?81o(dI@*;Z#NTRv)pO(T|%xuAPF z755GL8;g1P4H9TnLVwdR-(^HxrV!SXmBKb}F5!CrG^K1z_A$vPOu=dIELV|&6MmLI z9bn0;fqcS^;BkUt%n)2in1c5MkC9{_S!R`vB%7?#Hw3$oHmh`~;AoMY7wjgI5rX!3 z5mgKJ5YZ!okBa0&!CoR6M`)tXD*coKylPkwB2lvTO~3kX{& z#zBHh2-yW=f{Zf+7YY^;a^8zb%S+xb6n6os=!5;(yue{`S}Az^8(sIpS89>+QgBNN z6BJ{H;6lM7!NY=;g2xFt+~xO%Ym?{z`0Tb(`HEe$QEcq7W79rK!CcixeT1h8v$0xD zN~R9OAA@^*B{X-9Vd^X2T4G2Mo%*xyd1Yaz%c^|4RS5Zb;Mp(%`h{{-cZf4#GUt9phUI6Q!YcWnplZp;LuuP zi?CX7Xf078%&rB;)*7Ks98fJd`_||ytPBUKP;FeNW%$xtt=eL~t7}b5BqF&p&nrV9 zxLdWuAYtn%&}!8lW1}phIv`J2ZGh8F#!REL#WcBrG6jpG6RW9lRz+Dvb!=eS85^Ry zYSkILqAa4iG_dT7Ls4C|>WWh?v(NY=DvXOlO>C+7WsGSm-ifk^>fXSz2d7Sl>5_WJ zT~g1uOX?XnX_Waao6bx<8Ank zbzx(3?gyZy%MvZSL=8qqp%H15!RYBKxf2E>Qy8C73q#!Ojng4+fg=IVx1MpnL-3UA zlT)I16?z1rI!Uh$!*Q2UTiO_g(?YquEMk4TvS}H9q2E%&u-#=tbVLou-(1#PzpX~1 zLzpegaVYRR^$5~kc2|9%#$ce!J|{LFqg?i1#3o|A%f2FJXCX&u8RF;>A_tYd*r~}k z2j_*Ed~fo-gOzDrm6U&v6LE4#iy>0Yd965-t|87kRiT{CW7q zWlDdn=D{l+R)**BiJFhbE{j*6s0C>0vVO!Cp}ot#N9+l7b=gW{%aHCeu5TfB=koHV zzJ;i?g_>d%;&oxBz=epojPqTAo5oTKyaFG%Ixg@Ed@0O0UD=?(E29+(_`+q}q(#W1cVjLo7r!{B5$~#!nAW?i zO0iQc%kjCotJdLA9^ZdxB9~@8-e1UW%K4E>uZMq;VQVeF-iW@!Oom%9T9~QY7UT#s zRojC3F5{|g#d2dQRojYZTpd?!EA|ni^^MbQ__;Ba8_>1}Wvgdgwr#lTI_0X7ZZQXH zuI(M@x5O~6+71j8W~#OW|LHQW+76ShP5IVRzD_jX_myAo!lWnIjVb95@qL$Zo%Z7R zGS-!2hwrZ1i??0&A+i1V!e#x@Ojn@Aa$~uR*a4&&*7}^kg+7SU!fbOlK8R&PO(z`0 z7cS#0UPAtp?B-e23OgyxTtF|OiM)Q9Ko4V#uywfNYpsu9nXBWlk0P*=y_8{AfZ1qa zgxt;DJt)bKQ}h|a;sDpmgk z|LR&!RK4}tXs^-zANo9kt2nlDDa{3R6lVJ30{RIv&2|AJgqdc$fXOc7X1jyvCm6*&sb8RwuMW$<0?7QOYj%Tg5o9;z2ourQO`Kg2;z;U+|?qea2fYZ zq(Pt&bT1a4L4LTaXXMk4p~h*NYr4c5pd+YbJp;^oiEcgkejma7D0^Q00`EoH5dAB3 zrth-cY$1BwxPrmL%!BR~j2C7ebnPo_M@OwZvC;Yt`K@q;bqAN(K2cz)2p@zXQFZ=QP?Yzc3Nx*J!nH{*ExMtT=V2Q zQ!}nd?K-WOC|T@Y`9C1B?~_fmIBxcTUv2KK%7dzPQ)!kY_xEPkxr>eW@2Lmdn9AL+Hs;jC z`fM&87Dw2i-ZsAOJk>1_yI5=`_Dc}=N=&Xs8#}(YX7+7D=ICF*cHX9d>y}dbZ$Gk8^g#R{N}P z6gA8-FKN8#KcQCB^wIWF!k;0F@B$T|b`Rtd{+wP& zH9d1rBfLbXL({{`EW#U@LoNL_VOP{10lf^?R)S8Hx0G8w_TZ1%bTgG#MUlUQA_~j= zSE0`E9o(j?=6}k(&L37EbG8>f<1{bs>ta7Gp?8keS+muSLI - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -424,7 +424,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -450,7 +450,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -476,7 +476,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -915,7 +915,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.dll similarity index 62% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/sl5/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.dll index 4449f7841331fb012d4f0a79e730988bc5620707..4068317a26cc86d7852cfb9e40428d63914c7462 100644 GIT binary patch delta 8011 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
P_$p}N8vEEJ~OR)dwoblYlRyNs*Y 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 diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml new file mode 100644 index 00000000..ef8f0efe --- /dev/null +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml @@ -0,0 +1,1163 @@ + + + + SshNet.Security.Cryptography + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + Releases all resources used by the current instance of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Provides HMAC algorithm implementation. + + + + + Gets the size of the block. + + + The size of the block. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Initializes a with the specified hash algorithm. + + The hash provider. + is null. + + + + Initializes a with the specified hash algorithm, key and size of the computed + hash code. + + The hash provider. + The key. + The size, in bits, of the computed hash code. + is null. + + + + Initializes a with the specified hash algorithm and key. + + The hash provider. + The key. + is null. + + + + Gets or sets the key to use in the hash algorithm. + + + The key to use in the hash algorithm. + + + + + Initializes an implementation of the class. + + + + + Hashes the core. + + The RGB. + The ib. + The cb. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. + + + + Return a key that fits the of the . + + The key to shorten, if necessary. + + A hash of if is longer than the of the + ; otherwise, . + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + MD5 algorithm implementation + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Cryptographic hash function based upon the Merkle–Damgård construction. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Reset the chaining variables to the IV values. + + + + + Rounds 0-15 + + The x. + The y. + The z. + + + + + Rounds 16-31 + + The x. + The y. + The z. + + + + + ounds 32-47 + + The x. + The y. + The z. + + + + + Rounds 48-63 + + The x. + The y. + The z. + + + + + ounds 64-79 + + The x. + The y. + The z. + + + + + Computes the SHA1 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA256 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) + + + + + Initial hash value 1. + + + + + Initial hash value 2. + + + + + Initial hash value 3. + + + + + Initial hash value 4. + + + + + Initial hash value 5. + + + + + Initial hash value 6. + + + + + Initial hash value 7. + + + + + Initial hash value 8. + + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Initializes an implementation of the class. + + + + + Finalizes the hash computation. + + + + + Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. + + + + + Computes the SHA384 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA512 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/sl4/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.dll similarity index 62% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/sl4/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.dll index a65529bd9f1f79740579bfed360d495acd7582e7..100ad619c2c7f604f513af37297196db51d6e2be 100644 GIT binary patch delta 8011 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 diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.xml new file mode 100644 index 00000000..ef8f0efe --- /dev/null +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.xml @@ -0,0 +1,1163 @@ + + + + SshNet.Security.Cryptography + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + Releases all resources used by the current instance of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Provides HMAC algorithm implementation. + + + + + Gets the size of the block. + + + The size of the block. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Initializes a with the specified hash algorithm. + + The hash provider. + is null. + + + + Initializes a with the specified hash algorithm, key and size of the computed + hash code. + + The hash provider. + The key. + The size, in bits, of the computed hash code. + is null. + + + + Initializes a with the specified hash algorithm and key. + + The hash provider. + The key. + is null. + + + + Gets or sets the key to use in the hash algorithm. + + + The key to use in the hash algorithm. + + + + + Initializes an implementation of the class. + + + + + Hashes the core. + + The RGB. + The ib. + The cb. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. + + + + Return a key that fits the of the . + + The key to shorten, if necessary. + + A hash of if is longer than the of the + ; otherwise, . + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + MD5 algorithm implementation + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Cryptographic hash function based upon the Merkle–Damgård construction. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Reset the chaining variables to the IV values. + + + + + Rounds 0-15 + + The x. + The y. + The z. + + + + + Rounds 16-31 + + The x. + The y. + The z. + + + + + ounds 32-47 + + The x. + The y. + The z. + + + + + Rounds 48-63 + + The x. + The y. + The z. + + + + + ounds 64-79 + + The x. + The y. + The z. + + + + + Computes the SHA1 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA256 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) + + + + + Initial hash value 1. + + + + + Initial hash value 2. + + + + + Initial hash value 3. + + + + + Initial hash value 4. + + + + + Initial hash value 5. + + + + + Initial hash value 6. + + + + + Initial hash value 7. + + + + + Initial hash value 8. + + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Initializes an implementation of the class. + + + + + Finalizes the hash computation. + + + + + Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. + + + + + Computes the SHA384 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA512 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/uap10/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.dll similarity index 58% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/uap10/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.dll index dd70db74fa0f4b14e0406928b90e966dbb87496f..434ca153da02b4ae2da160c184c438b023093261 100644 GIT binary patch delta 8507 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 N7K&Ye%_vLv{0o%%d{Y1b delta 8402 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 Q&x73FwbA!~P7=?50hHBQGXMYp diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/uap10/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml similarity index 99% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/uap10/SshNet.Security.Cryptography.xml rename to packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml index 667cdd76..ec29c1a7 100644 --- a/packages/SshNet.Security.Cryptography.1.0.0/lib/uap10/SshNet.Security.Cryptography.xml +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml @@ -353,7 +353,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the MD5 hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -424,7 +424,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -450,7 +450,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -476,7 +476,7 @@ - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. @@ -915,7 +915,9 @@ Gets the size, in bits, of the computed hash code. - The size, in bits, of the computed hash code. + + The size, in bits, of the computed hash code. + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/net45/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.dll similarity index 62% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/net45/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.dll index c6653da75c192cd1f896fe23f448f734042ec8fd..b9d0c7ab0372bc6321e4423ece6045b6ecb560ff 100644 GIT binary patch delta 7985 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 N(GkA$s%lH~{x{scbkqxXb&IL>Cb>0_g4eK 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 F`#*_$H=+Ol diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml new file mode 100644 index 00000000..ef8f0efe --- /dev/null +++ b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml @@ -0,0 +1,1163 @@ + + + + SshNet.Security.Cryptography + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + Releases all resources used by the current instance of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Provides HMAC algorithm implementation. + + + + + Gets the size of the block. + + + The size of the block. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Initializes a with the specified hash algorithm. + + The hash provider. + is null. + + + + Initializes a with the specified hash algorithm, key and size of the computed + hash code. + + The hash provider. + The key. + The size, in bits, of the computed hash code. + is null. + + + + Initializes a with the specified hash algorithm and key. + + The hash provider. + The key. + is null. + + + + Gets or sets the key to use in the hash algorithm. + + + The key to use in the hash algorithm. + + + + + Initializes an implementation of the class. + + + + + Hashes the core. + + The RGB. + The ib. + The cb. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. + + + + Return a key that fits the of the . + + The key to shorten, if necessary. + + A hash of if is longer than the of the + ; otherwise, . + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + MD5 algorithm implementation + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Cryptographic hash function based upon the Merkle–Damgård construction. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Reset the chaining variables to the IV values. + + + + + Rounds 0-15 + + The x. + The y. + The z. + + + + + Rounds 16-31 + + The x. + The y. + The z. + + + + + ounds 32-47 + + The x. + The y. + The z. + + + + + Rounds 48-63 + + The x. + The y. + The z. + + + + + ounds 64-79 + + The x. + The y. + The z. + + + + + Computes the SHA1 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA256 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) + + + + + Initial hash value 1. + + + + + Initial hash value 2. + + + + + Initial hash value 3. + + + + + Initial hash value 4. + + + + + Initial hash value 5. + + + + + Initial hash value 6. + + + + + Initial hash value 7. + + + + + Initial hash value 8. + + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Initializes an implementation of the class. + + + + + Finalizes the hash computation. + + + + + Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. + + + + + Computes the SHA384 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA512 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + diff --git a/packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.dll similarity index 62% rename from packages/SshNet.Security.Cryptography.1.0.0/lib/wp71/SshNet.Security.Cryptography.dll rename to packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.dll index fc2092f578bb27b0f777f8ea9dff72d1c2e279e8..3d2ee74070dce6c9c96c3d685335c92b1303de49 100644 GIT binary patch delta 7776 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 + + + SshNet.Security.Cryptography + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + Releases all resources used by the current instance of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Provides HMAC algorithm implementation. + + + + + Gets the size of the block. + + + The size of the block. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Initializes a with the specified hash algorithm. + + The hash provider. + is null. + + + + Initializes a with the specified hash algorithm, key and size of the computed + hash code. + + The hash provider. + The key. + The size, in bits, of the computed hash code. + is null. + + + + Initializes a with the specified hash algorithm and key. + + The hash provider. + The key. + is null. + + + + Gets or sets the key to use in the hash algorithm. + + + The key to use in the hash algorithm. + + + + + Initializes an implementation of the class. + + + + + Hashes the core. + + The RGB. + The ib. + The cb. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. + + + + Return a key that fits the of the . + + The key to shorten, if necessary. + + A hash of if is longer than the of the + ; otherwise, . + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 64 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. + + + + + Initializes a with the specified key. + + The key. + + + + Initializes a with the specified key and size of the computed hash code. + + The key. + The size, in bits, of the computed hash code. + + + + Gets or sets the block size, in bytes, to use in the hash value. + + + The block size to use in the hash value. For this is 128 bytes. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Gets the value of the computed hash code. + + + The current value of the computed hash code. + + The object has already been disposed. + + + + Initializes an implementation of the . + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Computes the hash value for the specified region of the input byte array and copies the specified + region of the input byte array to the specified region of the output byte array. + + The input to compute the hash code for. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + A copy of the part of the input array used to compute the hash code. + The offset into the output byte array from which to begin writing data. + + The number of bytes written. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the specified region of the specified byte array. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + An array that is a copy of the part of the input that is hashed. + + + uses an invalid value. + -or- + has an invalid length. + + is null. + is out of range. This parameter requires a non-negative number. + The object has already been disposed. + + + + Computes the hash value for the input data. + + The input to compute the hash code for. + + The computed hash code. + + is null. + The object has already been disposed. + + + + MD5 algorithm implementation + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Cryptographic hash function based upon the Merkle–Damgård construction. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Reset the chaining variables to the IV values. + + + + + Rounds 0-15 + + The x. + The y. + The z. + + + + + Rounds 16-31 + + The x. + The y. + The z. + + + + + ounds 32-47 + + The x. + The y. + The z. + + + + + Rounds 48-63 + + The x. + The y. + The z. + + + + + ounds 64-79 + + The x. + The y. + The z. + + + + + Computes the SHA1 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA256 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Gets the input block size. + + + The input block size. + + + + + Gets the output block size. + + + The output block size. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) + + + + + Initial hash value 1. + + + + + Initial hash value 2. + + + + + Initial hash value 3. + + + + + Initial hash value 4. + + + + + Initial hash value 5. + + + + + Initial hash value 6. + + + + + Initial hash value 7. + + + + + Initial hash value 8. + + + + + The word buffer. + + + + + Initializes a new instance of the class. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Initializes an implementation of the class. + + + + + Finalizes the hash computation. + + + + + Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. + + + + + Computes the SHA384 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Computes the SHA512 hash for input data. + + + + + Initializes a new instance of the class. + + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + Routes data written to the object into the hash algorithm for computing the hash. + + The input to compute the hash code for. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the size, in bits, of the computed hash code. + + + The size, in bits, of the computed hash code. + + + + + When overridden in a derived class, gets the input block size. + + + The input block size. + + + + + When overridden in a derived class, gets the output block size. + + + The output block size. + + + + + Finalizes the hash computation after the last data is processed by the cryptographic stream object. + + + The computed hash code. + + + + + Initializes an implementation of the class. + + + + diff --git a/packages/System.IO.4.1.0/System.IO.4.1.0.nupkg b/packages/System.IO.4.1.0/System.IO.4.1.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..1210d81d0dabf7cbda6eaf75ff7e56b2bf37d7fa GIT binary patch literal 694059 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ǤEv~;bQ#E?h!s+FbIxiSx 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 K@PmH&?f(HTQj2l` literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.1.0/ThirdPartyNotices.txt b/packages/System.IO.4.1.0/ThirdPartyNotices.txt new file mode 100644 index 00000000..55cfb208 --- /dev/null +++ b/packages/System.IO.4.1.0/ThirdPartyNotices.txt @@ -0,0 +1,31 @@ +This Microsoft .NET Library may incorporate components from the projects listed +below. Microsoft licenses these components under the Microsoft .NET Library +software license terms. The original copyright notices and the licenses under +which Microsoft received such components are set forth below for informational +purposes only. Microsoft reserves all rights not expressly granted herein, +whether by implication, estoppel or otherwise. + +1. .NET Core (https://github.com/dotnet/core/) + +.NET Core +Copyright (c) .NET Foundation and Contributors + +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/packages/System.IO.4.1.0/dotnet_library_license.txt b/packages/System.IO.4.1.0/dotnet_library_license.txt new file mode 100644 index 00000000..92b6c443 --- /dev/null +++ b/packages/System.IO.4.1.0/dotnet_library_license.txt @@ -0,0 +1,128 @@ + +MICROSOFT SOFTWARE LICENSE TERMS + + +MICROSOFT .NET LIBRARY + +These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft + +· updates, + +· supplements, + +· Internet-based services, and + +· support services + +for this software, unless other terms accompany those items. If so, those terms apply. + +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE. + + +IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW. + +1. INSTALLATION AND USE RIGHTS. + +a. Installation and Use. You may install and use any number of copies of the software to design, develop and test your programs. + +b. Third Party Programs. The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only. + +2. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS. + +a. DISTRIBUTABLE CODE. The software is comprised of Distributable Code. “Distributable Code” is code that you are permitted to distribute in programs you develop if you comply with the terms below. + +i. Right to Use and Distribute. + +· You may copy and distribute the object code form of the software. + +· Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs. + +ii. Distribution Requirements. For any Distributable Code you distribute, you must + +· add significant primary functionality to it in your programs; + +· require distributors and external end users to agree to terms that protect it at least as much as this agreement; + +· display your valid copyright notice on your programs; and + +· indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs. + +iii. Distribution Restrictions. You may not + +· alter any copyright, trademark or patent notice in the Distributable Code; + +· use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; + +· include Distributable Code in malicious, deceptive or unlawful programs; or + +· modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that + +· the code be disclosed or distributed in source code form; or + +· others have the right to modify it. + +3. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not + +· work around any technical limitations in the software; + +· reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation; + +· publish the software for others to copy; + +· rent, lease or lend the software; + +· transfer the software or this agreement to any third party; or + +· use the software for commercial software hosting services. + +4. BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software. + +5. DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes. + +6. EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see www.microsoft.com/exporting. + +7. SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it. + +8. ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services. + +9. APPLICABLE LAW. + +a. United States. If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort. + +b. Outside the United States. If you acquired the software in any other country, the laws of that country apply. + +10. LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so. + +11. DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + +FOR AUSTRALIA – YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS. + +12. LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES. + +This limitation applies to + +· anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and + +· claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law. + +It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages. + +Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French. + +Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français. + +EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues. + +LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices. + +Cette limitation concerne : + +· tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et + +· les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur. + +Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard. + +EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas. + + diff --git a/packages/System.IO.4.1.0/lib/MonoAndroid10/_._ b/packages/System.IO.4.1.0/lib/MonoAndroid10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/MonoTouch10/_._ b/packages/System.IO.4.1.0/lib/MonoTouch10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/net45/_._ b/packages/System.IO.4.1.0/lib/net45/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/net462/System.IO.dll b/packages/System.IO.4.1.0/lib/net462/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..42d512c9f72a44680a1753e726221ea9c82a3930 GIT binary patch literal 22184 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 B6@35z literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.1.0/lib/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.1.0/lib/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/win8/_._ b/packages/System.IO.4.1.0/lib/win8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/wp80/_._ b/packages/System.IO.4.1.0/lib/wp80/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/wpa81/_._ b/packages/System.IO.4.1.0/lib/wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/xamarinios10/_._ b/packages/System.IO.4.1.0/lib/xamarinios10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/xamarinmac20/_._ b/packages/System.IO.4.1.0/lib/xamarinmac20/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/xamarintvos10/_._ b/packages/System.IO.4.1.0/lib/xamarintvos10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/lib/xamarinwatchos10/_._ b/packages/System.IO.4.1.0/lib/xamarinwatchos10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/MonoAndroid10/_._ b/packages/System.IO.4.1.0/ref/MonoAndroid10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/MonoTouch10/_._ b/packages/System.IO.4.1.0/ref/MonoTouch10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/net45/_._ b/packages/System.IO.4.1.0/ref/net45/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/net462/System.IO.dll b/packages/System.IO.4.1.0/ref/net462/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..42d512c9f72a44680a1753e726221ea9c82a3930 GIT binary patch literal 22184 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 B6@35z literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.1.0/ref/netcore50/System.IO.dll b/packages/System.IO.4.1.0/ref/netcore50/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..4bc64f3928aedae16e08170388511348dbf676e2 GIT binary patch literal 29864 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�$pQO;0L%zP?$;33|s|xiPHa)JnRw5;{9V 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 Wp1$q6S?`&3-GH>3>Qxc2ZvH + + + System.IO + + + +

Reads primitive data types as binary values in a specific encoding. + 2 + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The input stream. + The stream does not support reading, is null, or is already closed. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The input stream. + The character encoding to use. + The stream does not support reading, is null, or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The input stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support reading, is null, or is already closed. + + or is null. + + + Exposes access to the underlying stream of the . + The underlying stream associated with the BinaryReader. + 2 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Fills the internal buffer with the specified number of bytes read from the stream. + The number of bytes to be read. + The end of the stream is reached before could be read. + An I/O error occurs. + Requested is larger than the internal buffer size. + + + Returns the next available character and does not advance the byte or character position. + The next available character, or -1 if no more characters are available or the stream does not support seeking. + An I/O error occurs. + The current character cannot be decoded into the internal character buffer by using the selected for the stream. + 2 + + + Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + The next character from the input stream, or -1 if no characters are currently available. + An I/O error occurs. + The stream is closed. + 2 + + + Reads the specified number of bytes from the stream, starting from a specified point in the byte array. + The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of bytes to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of characters from the stream, starting from a specified point in the character array. + The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of characters to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads in a 32-bit integer in compressed format. + A 32-bit integer in compressed format. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + The stream is corrupted. + + + Reads a Boolean value from the current stream and advances the current position of the stream by one byte. + true if the byte is nonzero; otherwise, false. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the next byte from the current stream and advances the current position of the stream by one byte. + The next byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. + A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. + The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + An I/O error occurs. + The stream is closed. + + is negative. + 2 + + + Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + A character read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + A surrogate character was read. + 2 + + + Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. + A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. + The number of characters to read. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + The stream is closed. + An I/O error occurs. + + is negative. + 2 + + + Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. + A decimal value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. + An 8-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. + A 2-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. + A 4-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. + An 8-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a signed byte from this stream and advances the current position of the stream by one byte. + A signed byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. + A 4-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. + The string being read. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. + A 2-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. + A 4-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. + An 8-byte unsigned integer read from this stream. + The end of the stream is reached. + An I/O error occurs. + The stream is closed. + 2 + + + Writes primitive types in binary to a stream and supports writing strings in a specific encoding. + 2 + + + Initializes a new instance of the class that writes to a stream. + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The output stream. + The stream does not support writing or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The output stream. + The character encoding to use. + The stream does not support writing or is already closed. + + or is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The output stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support writing or is already closed. + + or is null. + + + Gets the underlying stream of the . + The underlying stream associated with the BinaryWriter. + 1 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Specifies a with no backing store. + 1 + + + Holds the underlying stream. + + + Sets the position within the current stream. + The position with the current stream. + A byte offset relative to . + A field of indicating the reference point from which the new position is to be obtained. + The file pointer was moved to an invalid location. + The value is invalid. + 1 + + + Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. + The Boolean value to write (0 or 1). + An I/O error occurs. + The stream is closed. + 1 + + + Writes an unsigned byte to the current stream and advances the stream position by one byte. + The unsigned byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a byte array to the underlying stream. + A byte array containing the data to write. + An I/O error occurs. + The stream is closed. + + is null. + 1 + + + Writes a region of a byte array to the current stream. + A byte array containing the data to write. + The starting point in at which to begin writing. + The number of bytes to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + The non-surrogate, Unicode character to write. + An I/O error occurs. + The stream is closed. + + is a single surrogate character. + 1 + + + Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + A character array containing the data to write. + + is null. + The stream is closed. + An I/O error occurs. + 1 + + + Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. + A character array containing the data to write. + The starting point in from which to begin writing. + The number of characters to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a decimal value to the current stream and advances the stream position by sixteen bytes. + The decimal value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. + The eight-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. + The two-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. + The four-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. + The eight-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a signed byte to the current stream and advances the stream position by one byte. + The signed byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. + The four-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. + The value to write. + An I/O error occurs. + + is null. + The stream is closed. + 1 + + + Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. + The two-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. + The four-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. + The eight-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a 32-bit integer in a compressed format. + The 32-bit integer to be written. + The end of the stream is reached. + The stream is closed. + The stream is closed. + + + The exception that is thrown when reading is attempted past the end of a stream. + 2 + + + Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. + + + Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + The exception that is thrown when a data stream is in an invalid format. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class with an expandable capacity initialized to zero. + + + Initializes a new non-resizable instance of the class based on the specified byte array. + The array of unsigned bytes from which to create the current stream. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. + The array of unsigned bytes from which to create this stream. + The setting of the property, which determines whether the stream supports writing. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + + is null. + + or is less than zero. + The buffer length minus is less than . + + + Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. + The array of unsigned bytes from which to create this stream. + The index in at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + + is null. + + or are negative. + The buffer length minus is less than . + + + Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. + + is null. + + or is negative. + The buffer length minus is less than . + + + Initializes a new instance of the class with an expandable capacity initialized as specified. + The initial size of the internal array in bytes. + + is negative. + + + Gets a value indicating whether the current stream supports reading. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports seeking. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 2 + + + Gets or sets the number of bytes allocated for this stream. + The length of the usable portion of the buffer for the stream. + A capacity is set that is negative or less than the current length of the stream. + The current stream is closed. + set is invoked on a stream whose capacity cannot be modified. + 2 + + + Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. + The token to monitor for cancellation requests. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Overrides the method so that no action is performed. + 2 + + + Asynchronously clears all buffers for this stream, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. + The stream has been disposed. + + + Gets the length of the stream in bytes. + The length of the stream in bytes. + The stream is closed. + 2 + + + Gets or sets the current position within the stream. + The current position within the stream. + The position is set to a negative value or a value greater than . + The stream is closed. + 2 + + + Reads a block of bytes from the current stream and writes the data to a buffer. + The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. + When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. + The zero-based byte offset in at which to begin storing data from the current stream. + The maximum number of bytes to read. + + is null. + + or is negative. + + subtracted from the buffer length is less than . + The current stream instance is closed. + 2 + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the current stream. + The byte cast to a , or -1 if the end of the stream has been reached. + The current stream instance is closed. + 2 + + + Sets the position within the current stream to the specified value. + The new position within the stream, calculated by combining the initial reference point and the offset. + The new position within the stream. This is relative to the parameter, and can be positive or negative. + A value of type , which acts as the seek reference point. + Seeking is attempted before the beginning of the stream. + + is greater than . + There is an invalid . -or- caused an arithmetic overflow. + The current stream instance is closed. + 2 + + + Sets the length of the current stream to the specified value. + The value at which to set the length. + The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. + + is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. + 2 + + + Writes the stream contents to a byte array, regardless of the property. + A new byte array. + 2 + + + Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. + true if the conversion was successful; otherwise, false. + The byte array segment from which this stream was created. + + + Writes a block of bytes to the current stream using data read from a buffer. + The buffer to write data from. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + + is null. + The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. + + subtracted from the buffer length is less than . + + or are negative. + An I/O error occurs. + The current stream instance is closed. + 2 + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current stream at the current position. + The byte to write. + The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. + The current stream is closed. + 2 + + + Writes the entire contents of this memory stream to another stream. + The stream to write this memory stream to. + + is null. + The current or target stream is closed. + 2 + + + Specifies the position in a stream to use for seeking. + 2 + + + Specifies the beginning of a stream. + + + Specifies the current position within a stream. + + + Specifies the end of a stream. + + + Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class. + + + When overridden in a derived class, gets a value indicating whether the current stream supports reading. + true if the stream supports reading; otherwise, false. + 1 + + + When overridden in a derived class, gets a value indicating whether the current stream supports seeking. + true if the stream supports seeking; otherwise, false. + 1 + + + Gets a value that determines whether the current stream can time out. + A value that determines whether the current stream can time out. + 2 + + + When overridden in a derived class, gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 1 + + + Reads the bytes from the current stream and writes them to another stream. + The stream to which the contents of the current stream will be copied. + + is null. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + The stream to which the contents of the current stream will be copied. + The size of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Asynchronously reads the bytes from the current stream and writes them to another stream. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + + is null. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + The token to monitor for cancellation requests. The default value is . + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases all resources used by the . + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. + An I/O error occurs. + 2 + + + Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. The default value is . + The stream has been disposed. + + + When overridden in a derived class, gets the length in bytes of the stream. + A long value representing the length of the stream in bytes. + A class derived from Stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + A Stream with no backing store. + 1 + + + When overridden in a derived class, gets or sets the position within the current stream. + The current position within the stream. + An I/O error occurs. + The stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. + An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. + The zero-based byte offset in at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The sum of and is larger than the buffer length. + + is null. + + or is negative. + An I/O error occurs. + The stream does not support reading. + Methods were called after the stream was closed. + 1 + + + Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. + The unsigned byte cast to an Int32, or -1 if at the end of the stream. + The stream does not support reading. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. + A value, in miliseconds, that determines how long the stream will attempt to read before timing out. + The method always throws an . + 2 + + + When overridden in a derived class, sets the position within the current stream. + The new position within the current stream. + A byte offset relative to the parameter. + A value of type indicating the reference point used to obtain the new position. + An I/O error occurs. + The stream does not support seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, sets the length of the current stream. + The desired length of the current stream in bytes. + An I/O error occurs. + The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 2 + + + When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + An array of bytes. This method copies bytes from to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + The sum of  and  is greater than the buffer length. + + is null. + + or  is negative. + An I/O error occured, such as the specified file cannot be found. + The stream does not support writing. + + was called after the stream was closed. + 1 + + + Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current position in the stream and advances the position within the stream by one byte. + The byte to write to the stream. + An I/O error occurs. + The stream does not support writing, or the stream is already closed. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. + A value, in miliseconds, that determines how long the stream will attempt to write before timing out. + The method always throws an . + 2 + + + Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream. + The stream to be read. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. + The stream to be read. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding. + The stream to be read. + The character encoding to use. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + The minimum buffer size. + The stream does not support reading. + + or is null. + + is less than or equal to zero. + + + Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. + The stream to read. + The character encoding to use. + true to look for byte order marks at the beginning of the file; otherwise, false. + The minimum buffer size. + true to leave the stream open after the object is disposed; otherwise, false. + + + Returns the underlying stream. + The underlying stream. + 2 + + + Gets the current character encoding that the current object is using. + The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. + 2 + + + Clears the internal buffer. + 2 + + + Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets a value that indicates whether the current stream position is at the end of the stream. + true if the current stream position is at the end of the stream; otherwise false. + The underlying stream has been disposed. + 1 + + + A object around an empty stream. + 1 + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. + An I/O error occurs. + 1 + + + Reads the next character from the input stream and advances the character position by one character. + The next character from the input stream represented as an object, or -1 if no more characters are available. + An I/O error occurs. + 1 + + + Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. + The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The index of at which to begin writing. + The maximum number of characters to read. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs, such as the stream is closed. + 1 + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurred. + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current stream and returns the data as a string. + The next line from the input stream, or null if the end of the input stream is reached. + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads a line of characters asynchronously from the current stream and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the stream. + The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. + The number of characters is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. + The stream to write to. + + is not writable. + + is null. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. + The stream to write to. + The character encoding to use. + + or is null. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + + or is null. + + is negative. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + true to leave the stream open after the object is disposed; otherwise, false. + + or is null. + + is negative. + + is not writable. + + + Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . + true to force to flush its buffer; otherwise, false. + 1 + + + Gets the underlying stream that interfaces with a backing store. + The stream this StreamWriter is writing to. + 2 + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + The current encoding does not support displaying half of a Unicode surrogate pair. + + + Gets the in which the output is written. + The specified in the constructor for the current instance, or if an encoding was not specified. + 2 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. + The current writer is closed. + An I/O error has occurred. + The current encoding does not support displaying half of a Unicode surrogate pair. + 1 + + + Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Provides a StreamWriter with no backing store that can be written to, but not read from. + 1 + + + Writes a character to the stream. + The character to write to the stream. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a character array to the stream. + A character array containing the data to write. If is null, nothing is written. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a subarray of characters to the stream. + A character array that contains the data to write. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The buffer length minus is less than . + + or is negative. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a string to the stream. + The string to write to the stream. If is null, nothing is written. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + An I/O error occurs. + 1 + + + Writes a character to the stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the stream asynchronously. + A task that represents the asynchronous write operation. + A character array that contains the data to write. + The character position in the buffer at which to begin reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string to the stream asynchronously. + A task that represents the asynchronous write operation. + The string to write to the stream. If is null, nothing is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Implements a that reads from a string. + 2 + + + Initializes a new instance of the class that reads from the specified string. + The string to which the should be initialized. + The parameter is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. + The current reader is closed. + 2 + + + Reads the next character from the input string and advances the character position by one character. + The next character from the underlying string, or -1 if no more characters are available. + The current reader is closed. + 2 + + + Reads a block of characters from the input string and advances the character position by . + The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The starting index in the buffer. + The number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The current reader is closed. + 2 + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current string and returns the data as a string. + The next line from the current string, or null if the end of the string is reached. + The current reader is closed. + There is insufficient memory to allocate a buffer for the returned string. + 2 + + + Reads a line of characters asynchronously from the current string and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the string and returns them as a single string. + The content from the current position to the end of the underlying string. + There is insufficient memory to allocate a buffer for the returned string. + The current reader is closed. + 2 + + + Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. + The number of characters is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing information to a string. The information is stored in an underlying . + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format control. + An object that controls formatting. + + + Initializes a new instance of the class that writes to the specified . + The StringBuilder to write to. + + is null. + + + Initializes a new instance of the class that writes to the specified and has the specified format provider. + The StringBuilder to write to. + An object that controls formatting. + + is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the in which the output is written. + The Encoding in which the output is written. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + + + Returns the underlying . + The underlying StringBuilder. + 2 + + + Returns a string containing the characters written to the current StringWriter so far. + The string containing the characters written to the current StringWriter. + 2 + + + Writes a character to the string. + The character to write. + The writer is closed. + 2 + + + Writes a subarray of characters to the string. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + + or is negative. + ( + )> . Length. + The writer is closed. + 2 + + + Writes a string to the current string. + The string to write. + The writer is closed. + 2 + + + Writes a character to the string asynchronously. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the string asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string to the current string asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the current string. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Represents a reader that can read a sequential series of characters. + 2 + + + Initializes a new instance of the class. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Provides a TextReader with no data to read from. + 1 + + + Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. + An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. + The is closed. + An I/O error occurs. + 1 + + + Reads the next character from the text reader and advances the character position by one character. + The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 2 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the text reader and returns the data as a string. + The next line from the reader, or null if all characters have been read. + An I/O error occurs. + There is insufficient memory to allocate a buffer for the returned string. + The is closed. + The number of characters in the next line is larger than + 1 + + + Reads a line of characters asynchronously and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. + The number of characters in the next line is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the text reader and returns them as one string. + A string that contains all characters from the current position to the end of the text reader. + An I/O error occurs. + The is closed. + There is insufficient memory to allocate a buffer for the returned string. + The number of characters in the next line is larger than + 1 + + + Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. + The number of characters is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Represents a writer that can write a sequential series of characters. This class is abstract. + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format provider. + An object that controls formatting. + + + Stores the newline characters used for this TextWriter. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, returns the character encoding in which the output is written. + The character encoding in which the output is written. + 1 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The text writer is disposed. + The writer is currently in use by a previous write operation. + + + Gets an object that controls formatting. + An object for a specific culture, or the formatting of the current culture if no other culture is specified. + 2 + + + Gets or sets the line terminator string used by the current TextWriter. + The line terminator string for the current TextWriter. + 2 + + + Provides a TextWriter with no backing store that can be written to, but not read from. + 1 + + + Writes the text representation of a Boolean value to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a character array to the text string or stream. + The character array to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters to the text string or stream. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte floating-point value to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object to the text string or stream by calling the ToString method on that object. + The object to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string to the text string or stream. + The string to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + + or is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character array to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If is null, nothing is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a line terminator to the text string or stream. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character followed by a line terminator to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes an array of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The character position in at which to start reading data. + The maximum number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value followed by a line terminator to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. + The object to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string followed by a line terminator to the text string or stream. + The string to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + A string or object is passed in as null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes an array of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If the character array is null, only the line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml new file mode 100644 index 00000000..07b2661f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. + 2 + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. + Der Eingabestream. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + oder ist null. + + + Gewährt Zugriff auf den zugrunde liegenden Stream von . + Der BinaryReader zugeordnete, zugrunde liegende Stream. + 2 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. + Die Anzahl der zu lesenden Bytes. + Das Ende des Streams ist erreicht, bevor gelesen werden konnte. + E/A-Fehler. + Die angeforderten überschreiten die interne Puffergröße. + + + Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. + Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. + 2 + + + Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. + Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Bytes. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 32-Bit-Ganzzahl in komprimiertem Format. + Eine 32-Bit-Ganzzahl in komprimiertem Format. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Der Datenstrom ist beschädigt. + + + Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + true, wenn das Byte ungleich 0 (null) ist, andernfalls false. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + Das nächste aus dem aktuellen Stream gelesene Byte. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. + Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + E/A-Fehler. + Der Stream ist geschlossen. + + ist negativ. + 2 + + + Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein aus dem aktuellen Stream gelesenes Zeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Ein Ersatzzeichenzeichen wurde gelesen. + 2 + + + Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Zeichen. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + Der Stream ist geschlossen. + E/A-Fehler. + + ist negativ. + 2 + + + Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. + Ein aus dem aktuellen Stream gelesener Dezimalwert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. + Die gelesene Zeichenfolge. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. + Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. + Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. + 2 + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. + + + Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. + Der Ausgabestream. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Ruft den zugrunde liegenden Stream von ab. + Der BinaryWriter zugeordnete, zugrunde liegende Stream. + 1 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Gibt eine -Klasse ohne Sicherungsspeicher an. + 1 + + + Enthält den zugrunde liegenden Stream. + + + Legt die Position im aktuellen Stream fest. + Die Position im aktuellen Stream. + Ein Byteoffset im Verhältnis zu . + Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. + Der Dateizeiger wurde an eine ungültige Position verschoben. + Der -Wert ist ungültig. + 1 + + + Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. + Der zu schreibende Boolean-Wert (0 (null) oder 1). + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Bytearray in den zugrunde liegenden Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + E/A-Fehler. + Der Stream ist geschlossen. + + ist null. + 1 + + + Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Bytes. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). + E/A-Fehler. + Der Stream ist geschlossen. + + ist ein einzelnes Ersatzzeichen. + 1 + + + Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + + ist null. + Der Stream ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. + Der zu schreibende Dezimalwert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Der zu schreibende 8-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Der zu schreibende 4-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. + Der zu schreibende Wert. + E/A-Fehler. + + ist null. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. + Die zu schreibende 32-Bit-Ganzzahl. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + Der Stream ist geschlossen. + + + Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. + 2 + + + Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. + + + Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. + + ist null. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + + Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + + ist null. + + oder ist kleiner als 0. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , bei dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. + Die Anfangsgröße des internen Arrays in Bytes. + + ist negativ. + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 2 + + + Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. + Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. + Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. + Der aktuelle Stream ist geschlossen. + set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. + 2 + + + Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. + Das Token zum überwachen von Abbruchanforderungen . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen . + Der Stream wurde freigegeben. + + + Ruft die Länge des Streams in Bytes ab. + Die Länge des Streams in Bytes. + Der Stream ist geschlossen. + 2 + + + Ruft die aktuelle Position im Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. + Der Stream ist geschlossen. + 2 + + + Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. + Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. + Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + + subtrahiert von der Pufferlänge ist kleiner als . + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem aktuellen Stream. + Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Position im aktuellen Stream auf den angegebenen Wert fest. + Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. + Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. + Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. + Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. + + ist größer als . + Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. + Der Wert, auf den die Länge festgelegt werden soll. + Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. + + ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. + 2 + + + Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. + Ein neues Bytearray. + 2 + + + Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. + true, wenn die Konvertierung erfolgreich war, andernfalls false. + Das Bytearraysegment, aus dem der Stream erstellt wurde. + + + Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. + + subtrahiert von der Pufferlänge ist kleiner als . + + oder ist negativ. + E/A-Fehler. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuelle Position im aktuellen Stream. + Das zu schreibende Byte. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. + Der aktuelle Stream ist geschlossen. + 2 + + + Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. + Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. + + ist null. + Der aktuelle Stream oder der Zielstream ist geschlossen. + 2 + + + Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. + 2 + + + Gibt den Anfang eines Streams an. + + + Gibt die aktuelle Position innerhalb eines Streams an. + + + Gibt das Ende eines Streams an. + + + Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. + 1 + + + Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + 2 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 1 + + + Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt alle vom verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + E/A-Fehler. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + Der Stream wurde freigegeben. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. + Ein Long-Wert, der die Länge des Streams in Bytes darstellt. + Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Ein Stream ohne Sicherungsspeicher. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. + Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. + Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. + Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. + Die Summe aus und ist größer als die Pufferlänge. + + ist null. + + oder ist negativ. + E/A-Fehler. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. + Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. + Die neue Position innerhalb des aktuellen Streams. + Ein Byteoffset relativ zum -Parameter. + Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. + Die gewünschte Länge des aktuellen Streams in Bytes. + E/A-Fehler. + Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. + Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. + Die Summe der  und  ist größer als die Länge des Puffers. + + ist null. + + oder  ist negativ. + E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. + Der Stream unterstützt das Schreiben nicht. + + wurde aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das Byte, das in den Stream geschrieben werden soll. + E/A-Fehler. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Der zu lesende Stream. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + Die Mindestgröße des Puffers. + Lesevorgänge werden vom Stream nicht unterstützt. + + oder ist null. + + ist kleiner oder gleich 0 (null). + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. + Die Mindestgröße des Puffers. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + + Gibt den zugrunde liegenden Stream zurück. + Der zugrunde liegende Stream. + 2 + + + Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. + Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. + 2 + + + Löscht den internen Puffer. + 2 + + + Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. + true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. + Der zugrunde liegende Stream wurde verworfen. + 1 + + + Ein -Objekt um einen leeren Stream. + 1 + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. + E/A-Fehler. + 1 + + + Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. + Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Index von , bei dem mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + Ein E/A-Fehler ist aufgetreten. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. + Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. + Die Anzahl der Zeichen ist niedriger als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + + ist schreibgeschützt. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + + oder ist null. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. + true, um zum Entleeren des Puffers zu zwingen, andernfalls false. + 1 + + + Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. + Der Stream, in den dieser StreamWriter schreibt. + 2 + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. + 2 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. + Der aktuelle Writer wird geschlossen. + Ein E/A-Fehler ist aufgetreten. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + 1 + + + Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt ein Zeichen in den Stream. + Das in den Stream zu schreibende Zeichen. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Zeichenarray in den Stream. + Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Teilarray von Zeichen in den Stream. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt eine Zeichenfolge in den Stream. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Implementiert einen , der aus einer Zeichenfolge liest. + 2 + + + Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. + Die Zeichenfolge, mit der der initialisiert werden soll. + Der -Parameter ist null. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Anfangsindex im Puffer. + Die Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. + Der aktuelle Reader ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + 2 + + + Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. + Die Anzahl der Zeichen ist niedriger als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. + Ein -Objekt zum Steuern der Formatierung. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . + Der StringBuilder, in den geschrieben werden soll. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. + Der StringBuilder, in den geschrieben werden soll. + Ein -Objekt zum Steuern der Formatierung. + + ist null. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die Encoding, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + + + Gibt den zugrunde liegenden zurück. + Der zugrunde liegende StringBuilder. + 2 + + + Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + 2 + + + Schreibt ein Zeichen in die Zeichenfolge. + Das zu schreibende Zeichen. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Teilarray von Zeichen in die Zeichenfolge. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + + oder ist negativ. + ( + )> .Length. + Der Writer ist geschlossen. + 2 + + + Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. + Die zu schreibende Zeichenfolge. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Stellt einen TextReader ohne zu lesende Daten bereit. + 1 + + + Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. + Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 2 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. + E/A-Fehler. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der ist geschlossen. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. + E/A-Fehler. + Der ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. + Die Anzahl der Zeichen ist niedriger als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. + Ein -Objekt zum Steuern der Formatierung. + + + Speichert die für diesen TextWriter verwendeten Zeilenendemarken. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. + Die Zeichencodierung, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Textwriter wird freigegeben. + Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Ruft ein Objekt zum Steuern der Formatierung ab. + Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. + 2 + + + Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. + Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. + 2 + + + Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichenarray. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. + Das zu schreibende Objekt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + + oder ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + Eine Zeichenfolge oder ein Objekt wird als null übergeben. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml new file mode 100644 index 00000000..0b2c206b --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml @@ -0,0 +1,2090 @@ + + + + System.IO + + + + Lee tipos de datos primitivos como valores binarios en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. + La secuencia de entrada. + La secuencia no admite la lectura, es null, o ya está cerrada. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de o es null. + + + Expone el acceso a la secuencia subyacente de . + Secuencia subyacente asociada a BinaryReader. + 2 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. + Número de bytes que se va a leer. + Se llega al final de la secuencia antes de se ha podido leer. + Se produce un error de E/S. + Solicitado es mayor que el tamaño del búfer interno. + + + Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. + Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. + 2 + + + Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. + Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. + Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de bytes que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. + Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de caracteres que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero de 32 bits en formato comprimido. + Entero de 32 bits en formato comprimido. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + La secuencia está dañada. + + + Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Es true si el byte es distinto de cero; en caso contrario, es false. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Siguiente byte que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. + Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. + Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + Se produce un error de E/S. + La secuencia está cerrada. + + es negativo. + 2 + + + Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. + Carácter que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + Se ha leído un carácter suplente. + 2 + + + Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. + Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. + Número de caracteres que se va a leer. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + La secuencia está cerrada. + Se produce un error de E/S. + + es negativo. + 2 + + + Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. + Valor decimal que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. + Valor de punto flotante de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. + Entero con signo de 2 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Entero con signo de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. + Entero con signo de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. + Byte con signo que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Valor de punto flotante de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. + Cadena que se lee. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. + Entero sin signo de 2 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. + Entero sin signo de 4 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. + Entero sin signo de 8 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase que escribe en una secuencia. + + + Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. + Flujo de salida. + La secuencia no admite escritura o ya se encuentra cerrada. + + es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + Flujo de salida. + Codificación de caracteres que se utilizará. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. + Flujo de salida. + Codificación de caracteres que se utilizará. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Obtiene la secuencia subyacente del objeto . + Flujo subyacente asociado a BinaryWriter. + 1 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Especifica un objeto sin memoria auxiliar. + 1 + + + Contiene la secuencia subyacente. + + + Establece la posición en la secuencia actual. + Posición con la secuencia actual. + Desplazamiento de bytes relacionado con . + Un campo de que indica el punto de referencia del que se obtiene la nueva posición. + El puntero de archivo se ha movido a una posición no válida. + El valor de no es válido. + 1 + + + Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. + Valor Boolean que se va a escribir (0 ó 1). + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte sin signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una matriz de bytes en la secuencia subyacente. + Matriz de bytes que contiene los datos que se van a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es null. + 1 + + + Escribe una región de una matriz de bytes en la secuencia actual. + Matriz de bytes que contiene los datos que se van a escribir. + Punto inicial de donde comenzará la escritura. + Número de bytes que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. + El carácter Unicode no suplente que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es un carácter suplente único. + 1 + + + Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + + es null. + La secuencia está cerrada. + Se produce un error de E/S. + 1 + + + Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Punto inicial de donde se empieza a leer. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. + Valor decimal que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Valor de punto flotante de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero con signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero con signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero con signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte con signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Valor de punto flotante de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. + Valor que se va a escribir. + Se produce un error de E/S. + + es null. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero sin signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero sin signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero sin signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero de 32 bits en formato comprimido. + Entero de 32 bits que se va a escribir. + Se llega al final de la secuencia. + La secuencia está cerrada. + La secuencia está cerrada. + + + Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. + 2 + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Excepción que se inicia cuando el formato de un flujo de datos no es válido. + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. + + + Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. + Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + El valor de es null. + + o es menor que cero. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + o son negativos. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. + El valor de es null. + + o es negativo. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. + Tamaño inicial de la matriz interna en bytes. + + es negativo. + + + Obtiene un valor que indica si la secuencia actual admite lectura. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite búsquedas. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 2 + + + Obtiene o establece el número de bytes asignados a esta secuencia. + Longitud de la parte utilizable del búfer para la secuencia. + Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. + La secuencia actual está cerrada. + set se invoca en una secuencia cuya capacidad no se puede modificar. + 2 + + + Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero. + Token para supervisar solicitudes de cancelación. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Reemplaza el método de modo que no se realice ninguna acción. + 2 + + + De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación. + Se ha eliminado la secuencia. + + + Obtiene la longitud de la secuencia en bytes. + Longitud de la secuencia en bytes. + La secuencia está cerrada. + 2 + + + Obtiene o establece la posición actual dentro de la secuencia. + Posición actual dentro de la secuencia. + La posición se establece en un valor negativo o un valor mayor que . + La secuencia está cerrada. + 2 + + + Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. + Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. + Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. + Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + + resta de la longitud del búfer es menor que . + La instancia de la secuencia actual está cerrada. + 2 + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia actual. + El byte convertido en un o -1 si se llega al final de la secuencia. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la posición dentro de la secuencia actual en el valor especificado. + Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. + Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. + Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. + Se ha intentado realizar una búsqueda antes del inicio de la secuencia. + + es mayor que . + Hay un no válido . o bien se produjo un desbordamiento aritmético. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la longitud de la secuencia actual en el valor especificado. + Valor en el que establecer la longitud. + La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. + + es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. + 2 + + + Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . + Nueva matriz de bytes. + 2 + + + Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. + Es true si la conversión se realiza correctamente; en caso contrario, es false. + El segmento de matriz de bytes desde el que se creó esta secuencia. + + + Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número máximo de bytes que se pueden escribir. + El valor de es null. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. + + resta de la longitud del búfer es menor que . + + o son negativos. + Se produce un error de E/S. + La instancia de la secuencia actual está cerrada. + 2 + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte en la posición actual de la secuencia actual. + Byte que se va a escribir. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. + La secuencia actual está cerrada. + 2 + + + Escribe el contenido completo de esta secuencia de memoria en otra secuencia. + Secuencia en la que se va a escribir esta secuencia de memoria. + El valor de es null. + La secuencia actual o de destino está cerrada. + 2 + + + Especifica la posición usada para buscar en una secuencia. + 2 + + + Especifica el comienzo de una secuencia. + + + Especifica lo posición actual dentro de la secuencia. + + + Especifica el final de una secuencia. + + + Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase . + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. + true si la secuencia admite lectura; en caso contrario, false. + 1 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. + true si la secuencia admite búsquedas; en caso contrario, false. + 1 + + + Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + 2 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 1 + + + Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera todos los recursos usados por . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Se produce un error de E/S. + 2 + + + Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + Se ha eliminado la secuencia. + + + Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. + Un valor Long que representa la longitud de la secuencia en bytes. + Una clase derivada de Stream no admite la búsqueda. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Stream sin memoria auxiliar. + 1 + + + Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. + Posición actual dentro de la secuencia. + Se produce un error de E/S. + La secuencia no admite búsquedas. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. + Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. + Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. + Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. + Número máximo de bytes que se deben leer de la secuencia actual. + La suma de y es mayor que la longitud del búfer. + El valor de es null. + + o es negativo. + Se produce un error de E/S. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. + Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. + La nueva posición dentro de la secuencia actual. + Desplazamiento de bytes relacionado con el parámetro . + Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. + Se produce un error de E/S. + La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. + Longitud deseada de la secuencia actual, en bytes. + Se produce un error de E/S. + La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. + Matriz de bytes.Este método copia bytes desde al flujo actual. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número de bytes que se deben escribir en la secuencia actual. + La suma de  y  es mayor que la longitud del búfer. + + es null. + + o  es negativo. + Se produjo un error de E/S, como no se puede encontrar el archivo especificado. + La secuencia no es compatible con la escritura. + + se llama después de cerrar la secuencia. + 1 + + + Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. + Byte que se debe escribir en la secuencia. + Se produce un error de E/S. + La secuencia no admite escritura o ya se encuentra cerrada. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 1 + + + Inicializa una nueva instancia de la clase para el flujo especificado. + Secuencia que se va a leer. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + Tamaño mínimo de búfer. + La secuencia no admite lectura. + El valor de o es null. + + es menor o igual que cero. + + + Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. + Tamaño mínimo de búfer. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + + + Devuelve la secuencia subyacente. + Secuencia subyacente. + 2 + + + Obtiene la codificación de caracteres que actualmente utiliza este objeto . + Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . + 2 + + + Borra el búfer interno. + 2 + + + Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene un valor que indica si la actual posición está al final de la secuencia. + Es true si la actual posición está al final de la secuencia; en caso contrario, es false. + Se ha eliminado la secuencia subyacente. + 1 + + + Objeto en torno a una secuencia vacía. + 1 + + + Devuelve el siguiente carácter disponible pero no lo consume. + Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. + El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. + Se produce un error de E/S. + 1 + + + Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. + Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Índice de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + La longitud del búfer menos es menor que . + El valor de es null. + + o es negativo. + Se produce un error de E/S, como el cierre de la secuencia. + 1 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + + o es negativo. + El se cierra. + Error de E/S. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. + El número de caracteres en la siguiente línea es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la secuencia. + Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. + El número de caracteres es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. + 1 + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + No se puede escribir en . + + is null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + + o es null. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . + Es true para que vacíe su búfer; en caso contrario, es false. + 1 + + + Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. + Secuencia en la que escribe este StreamWriter. + 2 + + + Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. + truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + + + Obtiene el donde se escribe el resultado. + + especificado en el constructor para la instancia actual o si no se ha especificado una codificación. + 2 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. + El sistema de escritura actual está cerrado. + Se produjo un error de E/S. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + 1 + + + Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe un carácter en la secuencia. + Carácter que se va a escribir en la secuencia. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una matriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una submatriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una cadena en la secuencia. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comienza la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Implementa que lee en una cadena. + 2 + + + Inicializa una nueva instancia de la clase que lee en la cadena especificada. + Cadena en la que debe inicializarse. + El parámetro es null. + + + Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Devuelve el siguiente carácter disponible pero no lo consume. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + El sistema de lectura actual está cerrado. + 2 + + + Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. + Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. + El sistema de lectura actual está cerrado. + 2 + + + Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . + Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Índice inicial del búfer. + Número de caracteres que se va a leer. + + es null. + La longitud del búfer menos es menor que . + + o son negativos. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. + El sistema de lectura actual está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + 2 + + + Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Contenido desde la posición actual hasta el final de la cadena subyacente. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. + El número de caracteres es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir información en una cadena.La información se almacena en el subyacente. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Inicializa una nueva instancia de la clase que escribe en el especificado. + Objeto StringBuilder en el que se va a escribir. + + es null. + + + Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. + Objeto StringBuilder en el que se va a escribir. + Objeto que controla las operaciones de formato. + + es null. + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene el donde se escribe el resultado. + Encoding donde se escribe el resultado. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + + + Devuelve el subyacente. + Objeto StringBuilder subyacente. + 2 + + + Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. + Cadena que contiene los caracteres escritos en el StringWriter actual. + 2 + + + Escribe un carácter en la cadena. + Carácter que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe una submatriz de caracteres en la cadena. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + + o son negativos. + ( + ) > .Length. + El sistema de escritura está cerrado. + 2 + + + Escribe una cadena en la cadena actual. + Cadena que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe un carácter en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena actual de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Representa un lector que puede leer una serie secuencial de caracteres. + 2 + + + Inicializa una nueva instancia de la clase . + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. + + + Proporciona un TextReader sin datos del que leer. + 1 + + + Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. + Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. + Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 2 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. + Línea siguiente del lector o null si se han leído todos los caracteres. + Se produce un error de E/S. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El objeto está cerrado. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. + Se produce un error de E/S. + El objeto está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. + El número de caracteres es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Almacena los caracteres de nueva línea usados para el TextWriter. + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. + Codificación de caracteres donde se escriben los resultados. + 1 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se desecha el sistema de escritura de texto. + El sistema de escritura está actualmente en uso por una operación de escritura anterior. + + + Obtiene un objeto que controla las operaciones de formato. + Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. + 2 + + + Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. + Cadena de terminador de línea para el TextWriter actual. + 2 + + + Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. + Objeto que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena en la cadena o secuencia de texto. + Cadena que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + El valor de o es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea en la cadena o secuencia. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + Posición del carácter en donde comenzar a leer datos. + Número máximo de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. + Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. + Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + Una cadena u objeto se pasa como null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml new file mode 100644 index 00000000..30dc29ab --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml @@ -0,0 +1,2201 @@ + + + + System.IO + + + + Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux d'entrée. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + + Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. + Flux d'entrée. + Encodage des caractères à utiliser. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux d'entrée. + Encodage des caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + ou a la valeur null. + + + Expose l'accès au flux sous-jacent de l'élément . + Flux sous-jacent associé à l'élément BinaryReader. + 2 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. + Nombre d'octets à lire. + La fin du flux est atteinte avant que n'ait pu être lu. + Une erreur d'E/S se produit. + + demandé est plus grand que la taille de la mémoire tampon interne. + + + Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. + Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. + 2 + + + Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. + Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre d'octets à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. + Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier 32 bits au format compressé. + Entier 32 bits au format compressé. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Le flux est endommagé. + + + Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. + true si l'octet est différent de zéro ; sinon, false. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. + Octet suivant lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. + Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. + Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Une erreur d'E/S se produit. + Le flux est fermé. + + est négatif. + 2 + + + Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. + Caractère lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Un caractère de substitution a été lu. + 2 + + + Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. + Nombre de caractères à lire. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Le flux est fermé. + Une erreur d'E/S se produit. + + est négatif. + 2 + + + Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. + Valeur décimale lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Valeur à virgule flottante de 8 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. + Entier signé de 2 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Entier signé de 4 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Entier signé de 8 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. + Octet signé lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Valeur à virgule flottante de 4 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. + Chaîne en cours de lecture. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. + Entier non signé de 2 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. + Entier non signé de 4 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. + Entier non signé de 8 octets lu dans ce flux. + La fin du flux est atteinte. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe qui écrit dans un flux. + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux de sortie. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. + Flux de sortie. + Encodage de caractères à utiliser. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux de sortie. + Encodage de caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Obtient le flux sous-jacent de . + Flux sous-jacent associé à BinaryWriter. + 1 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + 1 + + + Spécifie sans magasin de sauvegarde. + 1 + + + Contient le flux sous-jacent. + + + Définit la position dans le flux actuel. + Position dans le flux actuel. + Offset d'octet par rapport à . + Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. + Le pointeur de fichier a été déplacé vers un emplacement non valide. + La valeur n'est pas valide. + 1 + + + Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. + Valeur Boolean à écrire (0 ou 1). + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. + Octet non signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un tableau d'octets dans le flux sous-jacent. + Tableau d'octets contenant les données à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + a la valeur null. + 1 + + + Écrit une zone d'un tableau d'octets dans le flux actuel. + Tableau d'octets contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre d'octets à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Caractère Unicode de non-substitution à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + est un caractère de substitution unique. + 1 + + + Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Tableau de caractères contenant les données à écrire. + + a la valeur null. + Le flux est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. + Tableau de caractères contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. + Valeur décimale à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Valeur à virgule flottante de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. + Octet signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Valeur à virgule flottante de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. + Valeur à écrire. + Une erreur d'E/S se produit. + + a la valeur null. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier non signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier non signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier non signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un nombre entier 32 bits dans un format compressé. + Entier 32 bits à écrire. + La fin du flux est atteinte. + Le flux est fermé. + Le flux est fermé. + + + Exception levée en cas de tentative de lecture au-delà de la fin du flux. + 2 + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Exception qui est levée lorsque le format d'un flux de données n'est pas valide. + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. + Tableau d'octets non signés à partir duquel créer le flux actuel. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + + a la valeur null. + + ou est inférieur à zéro. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. + Taille initiale du tableau interne, en octets. + + est négatif. + + + Obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 2 + + + Obtient ou définit le nombre d'octets alloués pour ce flux. + Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. + La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. + Le flux actuel est fermé. + set est appelé sur un flux dont la capacité ne peut pas être modifiée. + 2 + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. + Jeton pour surveiller les demandes d'annulation. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplace la méthode afin qu'aucune action ne soit effectuée. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation. + Le flux a été supprimé. + + + Obtient la longueur du flux en octets. + Longueur du flux en octets. + Le flux est fermé. + 2 + + + Obtient ou définit la position actuelle dans le flux. + Position actuelle dans le flux. + La position correspond à une valeur négative ou à une valeur supérieure à . + Le flux est fermé. + 2 + + + Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. + Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. + Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + + soustrait à la longueur de la mémoire tampon est inférieur à . + L'instance du flux actuel est fermée. + 2 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet dans le flux actuel. + Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. + L'instance du flux actuel est fermée. + 2 + + + Définit la position dans le flux actuel à la valeur spécifiée. + Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. + Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. + Valeur de type , qui sert de point de référence à la recherche. + Tentative de recherche avant le début du flux. + + est supérieur à . + Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. + L'instance du flux actuel est fermée. + 2 + + + Définit la longueur du flux actuel à la valeur spécifiée. + Valeur à laquelle définir la longueur. + Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. + + est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. + 2 + + + Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . + Nouveau tableau d'octets. + 2 + + + Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. + true si la conversion a réussi ; sinon, false. + Segment de tableau d'octets à partir duquel ce flux a été créé. + + + Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre maximal d'octets à écrire. + + a la valeur null. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. + + soustrait à la longueur de la mémoire tampon est inférieur à . + + ou est négatif. + Une erreur d'E/S se produit. + L'instance du flux actuel est fermée. + 2 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux actuel. + Octet à écrire. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. + Le flux actuel est fermé. + 2 + + + Écrit le contenu complet de ce flux de mémoire dans un autre flux. + Flux dans lequel écrire ce flux de mémoire. + + a la valeur null. + Le flux en cours ou le flux cible est fermé. + 2 + + + Spécifie la position au sein d'un flux à utiliser pour la recherche. + 2 + + + Spécifie le début d'un flux. + + + Spécifie la position actuelle au sein d'un flux. + + + Spécifie la fin d'un flux. + + + Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe . + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux prend en charge la lecture ; sinon, false. + 1 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux prend en charge la recherche ; sinon, false. + 1 + + + Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + 2 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 1 + + + Lit les octets du flux actuel et les écrit dans un autre flux. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Flux vers lequel le contenu du flux actuel sera copié. + Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. + Une erreur d'E/S se produit. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + Le flux a été supprimé. + + + En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. + Valeur de type long représentant la longueur du flux en octets. + Une classe dérivée de Stream ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Élément Stream sans magasin de stockage. + 1 + + + En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. + Position actuelle dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. + Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. + Nombre maximal d'octets à lire dans le flux actuel. + La somme de et de est supérieure à la longueur de la mémoire tampon. + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. + Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. + Nouvelle position dans le flux actuel. + Offset d'octet par rapport au paramètre . + Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. + Longueur souhaitée du flux actuel en octets. + Une erreur d'E/S se produit. + Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. + Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre d'octets à écrire dans le flux actuel. + La somme des  et  est supérieure à la longueur du tampon. + + est null. + + ou  est un nombre négatif. + Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. + Le flux ne prend pas en charge l'écriture. + + a été appelée une fois que le flux a été fermé. + 1 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. + Octet à écrire dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié. + Flux à lire. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. + Flux à lire. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. + Flux à lire. + Encodage des caractères à utiliser. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + Taille minimale de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + + ou a la valeur null. + + est inférieur ou égal à zéro. + + + Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à lire. + Encodage des caractères à utiliser. + true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. + Taille minimale de la mémoire tampon. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + + Retourne le flux sous-jacent. + Flux sous-jacent. + 2 + + + Obtient l'encodage de caractères actuel utilisé par l'objet actuel. + Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . + 2 + + + Efface la mémoire tampon interne. + 2 + + + Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. + true si la position actuelle dans le flux est à la fin du flux ; sinon, false. + Le flux sous-jacent a été supprimé. + 1 + + + Objet autour d'un flux vide. + 1 + + + Retourne le caractère disponible suivant, mais ne le consomme pas. + Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. + Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. + Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Index de auquel commencer l'écriture. + Nombre maximal de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S, telle que la fermeture du flux, se produit. + 1 + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S s'est produite. + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. + Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du flux. + Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. + Le nombre de caractères est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. + Le flux dans lequel écrire. + + n'est pas accessible en écriture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + + ou est null. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . + true pour forcer à vider sa mémoire tampon ; sinon, false. + 1 + + + Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. + Flux dans lequel ce StreamWriter écrit. + 2 + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + + + Obtient le dans lequel la sortie est écrite. + + spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. + 2 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. + Le writer actuel est fermé. + Une erreur d'E/S s'est produite. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + 1 + + + Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. + 1 + + + Écrit un caractère dans le flux. + Caractère à écrire dans le flux. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un sous-tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit une chaîne dans le flux. + Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire où commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire dans le flux.Si est null, rien n'est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un terminateur de ligne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Implémente qui lit une chaîne. + 2 + + + Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. + Chaîne à laquelle doit être initialisé. + Le paramètre est null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Retourne le prochain caractère disponible, mais ne le consomme pas. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Le lecteur actuel est fermé. + 2 + + + Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. + Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. + Le lecteur actuel est fermé. + 2 + + + Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . + Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Index de début dans la mémoire tampon. + Nombre de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Le lecteur actuel est fermé. + 2 + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. + Le lecteur actuel est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + 2 + + + Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. + Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le lecteur actuel est fermé. + 2 + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. + Le nombre de caractères est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. + Objet qui contrôle la mise en forme. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié. + StringBuilder dans lequel écrire. + + a la valeur null. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. + StringBuilder dans lequel écrire. + Objet qui contrôle la mise en forme. + + a la valeur null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le dans lequel la sortie est écrite. + Encoding dans lequel la sortie est écrite. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + + + Retourne le sous-jacent. + StringBuilder sous-jacent. + 2 + + + Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. + Chaîne contenant les caractères écrits dans le StringWriter en cours. + 2 + + + Écrit un caractère dans la chaîne. + Caractère à écrire. + Le writer est fermé. + 2 + + + Écrit un sous-tableau de caractères dans la chaîne. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + ou est négatif. + ( + )> .Length. + Le writer est fermé. + 2 + + + Écrit une chaîne dans la chaîne actuelle. + Chaîne à écrire. + Le writer est fermé. + 2 + + + Écrit un caractère dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans la chaîne actuelle de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Représente un lecteur capable de lire une série séquentielle de caractères. + 2 + + + Initialise une nouvelle instance de la classe . + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Fournit un TextReader sans données à lire. + 1 + + + Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. + Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. + Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. + La ligne suivante du lecteur ou null si tous les caractères ont été lus. + Une erreur d'E/S se produit. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + + est fermé. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. + Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. + Une erreur d'E/S se produit. + + est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. + Le nombre de caractères est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. + Objet qui contrôle la mise en forme. + + + Stocke les caractères de saut de ligne utilisés pour ce TextWriter. + + + Libère toutes les ressources utilisées par l'objet . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. + Encodage de caractères dans lequel la sortie est écrite. + 1 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le writer de texte est supprimé. + Le writer est actuellement utilisé par une opération d'écriture précédente. + + + Obtient un objet qui contrôle la mise en forme. + Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. + 2 + + + Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. + Chaîne de marque de fin de ligne pour le TextWriter actuel. + 2 + + + Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. + Objet à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne dans la chaîne ou le flux de texte. + Chaîne à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + + ou a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + Dans , position de caractère à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + Une chaîne ou un objet est passé en tant que null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml new file mode 100644 index 00000000..46070bec --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml @@ -0,0 +1,2123 @@ + + + + System.IO + + + + Legge i tipi di dati primitivi come valori binari in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. + Flusso di input. + Il flusso non supporta la lettura, è null o è già chiuso. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. + Flusso di input. + Codifica dei caratteri da usare. + Il flusso non supporta la lettura, è null o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. + Flusso di input. + Codifica dei caratteri da usare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la lettura, è null o è già chiuso. + + o è null. + + + Espone l'accesso al flusso sottostante dell'oggetto . + Flusso sottostante associato all'oggetto BinaryReader. + 2 + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Inserisce nel buffer interno il numero specificato di byte letti dal flusso. + Numero di byte da leggere. + È stata raggiunta la fine del flusso prima che fosse possibile leggere . + Si è verificato un errore di I/O. + I richiesti sono superiori alla dimensione del buffer interno. + + + Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. + Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. + 2 + + + Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. + Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. + Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di byte da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. + Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di caratteri da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero a 32 bit in formato compresso. + Intero a 32 bit in formato compresso. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + Flusso danneggiato. + + + Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + true se il byte è diverso da zero; in caso contrario, false. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + Byte successivo letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. + Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. + Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è negativo. + 2 + + + Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Carattere letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + È stato letto un carattere surrogato. + 2 + + + Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. + Numero di caratteri da leggere. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Il flusso è chiuso. + Si è verificato un errore di I/O. + + è negativo. + 2 + + + Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. + Valore decimale letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. + Valore a virgola mobile a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. + Intero con segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Intero con segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. + Intero con segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. + Byte con segno letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Valore a virgola mobile a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. + Stringa da leggere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. + Intero senza segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero senza segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero senza segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe che scrive in un flusso. + + + Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. + Flusso di output. + Il flusso non supporta la scrittura o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. + Flusso di output. + Codifica dei caratteri da utilizzare. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso di output. + Codifica dei caratteri da utilizzare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Ottiene il flusso sottostante dell'oggetto . + Flusso sottostante associato a BinaryWriter. + 1 + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Specifica un oggetto privo di archivio di backup. + 1 + + + Contiene il flusso principale. + + + Imposta la posizione all'interno del flusso corrente. + Posizione all'interno del flusso corrente. + Offset dei byte relativo a . + Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. + Il puntatore a file è stato spostato in un percorso non valido. + Il valore di non è valido. + 1 + + + Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. + Valore Boolean da scrivere (0 o 1). + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una matrice di byte nel flusso sottostante. + Matrice di caratteri che contiene i dati da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è null. + 1 + + + Scrive un'area di una matrice di byte nel flusso corrente. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale nel parametro da cui iniziare la scrittura. + Numero di byte da scrivere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Carattere Unicode non surrogato da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è un carattere surrogato singolo. + 1 + + + Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + + è null. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 1 + + + Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale in dal quale avviare la scrittura. + Numero di caratteri da inserire. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. + Valore decimale da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Valore a virgola mobile a otto byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Valore a virgola mobile a quattro byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. + Valore da scrivere. + Si è verificato un errore di I/O. + + è null. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Inserisce un valore intero a 32 bit in un formato compresso. + Intero da 32 bit da scrivere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Il flusso è chiuso. + + + Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. + 2 + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Eccezione generata se un flusso di dati è in un formato non valido. + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. + Matrice di byte senza segno da cui creare il flusso corrente. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + + è null. + + o è minore di zero. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + o è un valore negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. + + è null. + Il valore di o è negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. + Dimensione iniziale in byte della matrice interna. + + è negativo. + + + Ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 2 + + + Ottiene o imposta il numero di byte allocati per questo flusso. + Lunghezza della parte usabile del buffer per il flusso. + È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. + Il flusso corrente è chiuso. + set è stato richiamato su un flusso del quale non è possibile modificare la capacità. + 2 + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. + Token da monitorare per le richieste di annullamento. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. + 2 + + + Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento. + Il flusso è stato eliminato. + + + Ottiene la lunghezza in byte del flusso. + Lunghezza del flusso in byte. + Il flusso è chiuso. + 2 + + + Ottiene o imposta la posizione corrente all'interno del flusso. + Posizione corrente all'interno del flusso. + La posizione è impostata su un valore negativo o maggiore di . + Il flusso è chiuso. + 2 + + + Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. + Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. + Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. + Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + + sottratto alla lunghezza del buffer è minore di . + L'istanza del flusso corrente è chiusa. + 2 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso corrente. + Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la posizione all'interno del flusso corrente sul valore specificato. + Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. + Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. + Valore di tipo , che funge da punto di riferimento per la ricerca. + La ricerca viene tentata prima dell'inizio del flusso. + + è maggiore di . + Il valore di non è valido. -oppure- causato da un overflow aritmetico. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la lunghezza del flusso corrente sul valore specificato. + Valore su cui impostare la lunghezza. + Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. + + è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. + 2 + + + Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . + Nuova matrice di byte. + 2 + + + Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. + true se la conversione riesce; in caso contrario, false. + Segmento di matrice di byte da cui è stato creato questo flusso. + + + Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero massimo di byte da scrivere. + + è null. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. + + sottratto alla lunghezza del buffer è minore di . + + o è un valore negativo. + Si è verificato un errore di I/O. + L'istanza del flusso corrente è chiusa. + 2 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente all'interno del flusso corrente. + Byte da scrivere. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. + Il flusso corrente è chiuso. + 2 + + + Scrive l'intero contenuto del flusso di memoria in un altro flusso. + Flusso in cui scrivere il flusso di memoria. + + è null. + Il flusso corrente o di destinazione è chiuso. + 2 + + + Specifica la posizione in un flusso da utilizzare per le ricerche. + 2 + + + Specifica l'inizio di un flusso. + + + Specifica la posizione corrente all'interno di un flusso. + + + Specifica la fine di un flusso. + + + Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso supporta la lettura; in caso contrario, false. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso supporta la ricerca; in caso contrario, false. + 1 + + + Ottiene un valore che determina se il flusso corrente prevede il timeout. + Valore che determina se il flusso corrente prevede il timeout. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 1 + + + Legge i byte dal flusso corrente e li scrive in un altro flusso. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Si è verificato un errore di I/O. + 2 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + Il flusso è stato eliminato. + + + Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. + Valore long che rappresenta la lunghezza del flusso in byte. + Una classe derivata da Stream non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Oggetto Stream privo di archivio di backup. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. + Posizione corrente all'interno del flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. + Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. + Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. + Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. + Numero massimo di byte da leggere dal flusso corrente. + La somma di e è maggiore della lunghezza del buffer. + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. + Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. + Nuova posizione all'interno del flusso corrente. + Offset dei byte rispetto al parametro . + Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. + Lunghezza desiderata del flusso corrente in byte. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. + Matrice di byte.Questo metodo copia i byte da nel flusso corrente. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero di byte da scrivere nel flusso corrente. + La somma di  e  è maggiore della lunghezza del buffer. + + è null. + + o  è negativo. + Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. + Il flusso non supporta la scrittura. + + è stato chiamato dopo la chiusura del flusso. + 1 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. + Byte da scrivere nel flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura o è già chiuso. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato. + Flusso da leggere. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. + Flusso da leggere. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. + Flusso da leggere. + Codifica dei caratteri da usare. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + Dimensione minima del buffer. + Il flusso non supporta la lettura. + + o è null. + + è minore o uguale a zero. + + + Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. + Flusso da leggere. + Codifica dei caratteri da usare. + true per cercare i byte order mark all'inizio del file; in caso contrario, false. + Dimensione minima del buffer. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + + Restituisce il flusso sottostante. + Flusso sottostante. + 2 + + + Ottiene la codifica caratteri corrente usata dall'oggetto corrente. + Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . + 2 + + + Cancella il buffer interno. + 2 + + + Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. + true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. + Il flusso sottostante è stato eliminato. + 1 + + + Oggetto che include un flusso vuoto. + 1 + + + Restituisce il carattere successivo disponibile senza usarlo. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. + Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Indice di da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O, come la chiusura del flusso. + 1 + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. + Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. + Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. + Il numero di caratteri è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. + Flusso in cui scrivere. + + non è modificabile. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + + o è null. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + + o è null. + + è negativo. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + o è null. + + è negativo. + + non è modificabile. + + + Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . + true per forzare lo scaricamento del buffer; in caso contrario, false. + 1 + + + Ottiene il flusso sottostante che si interfaccia con un archivio di backup. + Flusso in cui StreamWriter scrive. + 2 + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + + + Ottiene l'oggetto in cui viene scritto l'output. + Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. + 2 + + + Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. + Il writer corrente è chiuso. + Si è verificato un errore di I/O. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive un carattere nel flusso. + Carattere da scrivere nel flusso. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una matrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una sottomatrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una stringa nel flusso. + Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Implementa un oggetto che legge da una stringa. + 2 + + + Inizializza una nuova istanza della classe che legge dalla stringa specificata. + Stringa sulla quale inizializzare . + Il parametro è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Restituisce il carattere successivo disponibile senza utilizzarlo. + Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Il lettore corrente è chiuso. + 2 + + + Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. + Il lettore corrente è chiuso. + 2 + + + Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . + Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Indice iniziale nel buffer. + Numero di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. + Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. + Il lettore corrente è chiuso. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + 2 + + + Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Contenuto dalla posizione corrente alla fine della stringa sottostante. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. + Il numero di caratteri è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il controllo di formato specificato. + Oggetto che controlla la formattazione. + + + Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. + Oggetto StringBuilder in cui scrivere. + + è null. + + + Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. + Oggetto StringBuilder in cui scrivere. + Oggetto che controlla la formattazione. + + è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Recupera l'oggetto in cui viene scritto l'output. + Encoding in cui viene scritto l'output. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di svuotamento asincrona. + + + Restituisce l'oggetto sottostante. + StringBuilder sottostante. + 2 + + + Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. + Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. + 2 + + + Scrive un carattere nella stringa. + Carattere da inserire. + Il writer è chiuso. + 2 + + + Scrive una sottomatrice di caratteri nella stringa. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + Il valore di o è negativo. + ( + )> .Length. + Il writer è chiuso. + 2 + + + Scrive una stringa nella stringa corrente. + Stringa da scrivere. + Il writer è chiuso. + 2 + + + Scrive un carattere nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nella stringa corrente in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. + 2 + + + Inizializza una nuova istanza della classe . + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. + 1 + + + Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. + Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 2 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. + Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. + Si è verificato un errore di I/O. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + La classe è chiusa. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. + Si è verificato un errore di I/O. + La classe è chiusa. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. + Il numero di caratteri è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il provider di formato specificato. + Oggetto che controlla la formattazione. + + + Archivia i caratteri di nuova riga usati per questo TextWriter. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. + Codifica caratteri in cui viene scritto l'output. + 1 + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il writer di testo viene eliminato. + Il writer è attualmente utilizzato da un'operazione di scrittura precedente. + + + Ottiene un oggetto che controlla la formattazione. + Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. + 2 + + + Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. + Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. + 2 + + + Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nella stringa o flusso di testo. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri nella stringa o flusso di testo. + Matrice di caratteri da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. + Oggetto da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa nella stringa o nel flusso di testo. + Stringa da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + + o è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso o nella stringa di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + Posizione del carattere in dalla quale avviare la lettura dei dati. + Numero massimo di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + Viene passato un oggetto o una stringa come null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml new file mode 100644 index 00000000..4114d626 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml @@ -0,0 +1,2264 @@ + + + + System.IO + + + + プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 + 2 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + 使用する文字エンコーディング。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + は null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + または が null です。 + + + + の基になるストリームへのアクセスを公開します。 + BinaryReader に関連付けられた、基になるストリーム。 + 2 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 + 読み取るバイト数。 + + 分のバイトを読み取る前にストリームの末尾に到達しました。 + I/O エラーが発生しました。 + 要求された が、内部バッファー サイズより大きくなっています。 + + + 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 + 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 + 2 + + + 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 + + に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取るバイト数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 + バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取る文字の数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 32 ビット整数を圧縮形式で読み取ります。 + 圧縮形式の 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + ストリームが破損しています。 + + + 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った次のバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 + 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + が負の値です。 + 2 + + + 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 現在のストリームから読み取った文字。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + サロゲート文字が読み取られました。 + 2 + + + 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 + 読み取る文字の数。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + + が負の値です。 + 2 + + + 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 + 現在のストリームから読み取った 10 進数値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った符号付きバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 + 読み取った文字列。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号なし整数。 + ストリームの末尾に到達しました。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 + 2 + + + ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + は null なので、 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + 使用する文字エンコーディング。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 出力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + + の基になるストリームを取得します。 + BinaryWriter に関連付けられた、基になるストリーム。 + 1 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + バッキング ストアを持たない を指定します。 + 1 + + + 基になるストリームを保持します。 + + + 現在のストリーム内の位置を設定します。 + 現在のストリームの位置。 + + からのバイト オフセット。 + 新しい位置を取得するための参照ポイントを示す フィールド。 + ファイル ポインターが無効な位置に移動しました。 + + 値が無効です。 + 1 + + + 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 + 書き込む Boolean 値 (0 または 1)。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号なしバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 基になるストリームにバイト配列を書き込みます。 + 書き込むデータが格納されているバイト配列。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は null なので、 + 1 + + + 現在のストリームにバイト配列の特定の領域を書き込みます。 + 書き込むデータが格納されているバイト配列。 + + 内の書き込み開始点。 + 書き込むバイト数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む非サロゲート Unicode 文字。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は、単一のサロゲート文字です。 + 1 + + + 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + は null なので、 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + 内の書き込み開始点。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 + 書き込む 10 進値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号付きバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む値。 + I/O エラーが発生しました。 + + は null なので、 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 32 ビット整数を圧縮形式で書き込みます。 + 書き込む 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + ストリームが閉じられました。 + + + ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 + 2 + + + メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 + + + メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データ ストリームが無効な形式である場合にスローされる例外。 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 + + + 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + 現在のストリームを作成する符号なしバイトの配列。 + + は null です。 + + + + プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + + バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + + は null です。 + + または が 0 未満です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 + バイト単位の内部配列の初期サイズ。 + + が負の値です。 + + + 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 2 + + + ストリームに割り当てられたバイト数を取得または設定します。 + ストリームに対してバッファーが使用できる部分の長さ。 + 容量が負の値または現在のストリーム長より小さい値に設定されています。 + 現在のストリームが閉じています。 + 容量を変更できないストリームに対して set が呼び出されました。 + 2 + + + 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 + キャンセル要求を監視するためのトークン。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + アクションが実行されないように、 メソッドをオーバーライドします。 + 2 + + + このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。 + ストリームは破棄されています。 + + + バイト単位のストリーム長を取得します。 + バイト単位のストリーム長。 + ストリームが閉じられました。 + 2 + + + ストリームの現在位置を取得または設定します。 + ストリーム内の現在位置。 + 位置が負の値または より大きい値に設定されています。 + ストリームが閉じられました。 + 2 + + + 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 + バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 + このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 + 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームからバイトを読み取ります。 + + にキャストしたバイト。ストリームの末尾に達した場合は -1。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム内の位置を指定した値に設定します。 + 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 + ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 + シーク参照ポイントとして機能する 型の値。 + ストリームの先頭より前をシークしようとしました。 + + が より大きくなっています。 + 無効な があります。または によって算術オーバーフローが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム長を指定した値に設定します。 + 長さを設定する値。 + 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 + + が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 + 2 + + + + プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 + 新しいバイト配列。 + 2 + + + このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 + 変換が成功した場合は true。それ以外の場合は false。 + このストリームの作成元のバイト配列セグメント。 + + + バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 + データの書き込み元となるバッファー。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリーム内の現在位置に 1 バイトを書き込みます。 + 書き込むバイト。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 + 現在のストリームが閉じています。 + 2 + + + メモリ ストリームの内容全体を別のストリームに書き込みます。 + このメモリ ストリームが書き込まれるストリーム。 + + は null です。 + 現在のストリームまたは対象のストリームは閉じています。 + 2 + + + シークに使用するストリームの場所を指定します。 + 2 + + + ストリームの先頭を指定します。 + + + ストリーム内の現在位置を指定します。 + + + ストリームの末尾を指定します。 + + + バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 + ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 + ストリームがシークをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 + 現在のストリームがタイムアウトできるかどうかを決定する値。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + によって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + I/O エラーが発生しました。 + 2 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。既定値は です。 + ストリームは破棄されています。 + + + 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 + ストリーム長 (バイト単位) を表す long 値。 + Stream から派生したクラスがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + バッキング ストアを持たない Stream。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 + ストリーム内の現在位置。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 + バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 + バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 + 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームから読み取る最大バイト数。 + + と の合計値が、バッファー長より大きい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 + Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 + 現在のストリーム内の新しい位置。 + + パラメーターからの相対バイト オフセット。 + 新しい位置を取得するために使用する参照ポイントを示す 型の値。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 + 現在のストリームの希望の長さ (バイト数)。 + I/O エラーが発生しました。 + ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 + バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームに書き込むバイト数。 + 合計  と  がバッファーの長さより大きい。 + + nullです。 + + または  が負の値です。 + 指定したファイルが見つからないなど、I/O エラーが発生しました。 + ストリームは書き込みをサポートしません。 + + ストリームが閉じられた後が呼び出されました。 + 1 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + ストリームに書き込むバイト。 + I/O エラーが発生しました。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 1 + + + 指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + + が読み取りをサポートしていません。 + + は null です。 + + + バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + は null です。 + + + 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + 最小バッファー サイズ。 + ストリームは読み取りをサポートしません。 + + または が null です。 + + が 0 以下です。 + + + 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 読み取るストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 + 最小バッファー サイズ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + + 基になるストリームを返します。 + 基になるストリーム。 + 2 + + + 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 + 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 + 2 + + + 内部バッファーをクリアします。 + 2 + + + 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 + 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 + 基になるストリームは破棄されています。 + 1 + + + 空のストリームの オブジェクト。 + 1 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 + 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 + 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みの開始位置を示す のインデックス。 + 読み取り対象の最大文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。たとえば、ストリームがクローズされています。 + 1 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 + 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + すべての文字の現在位置から末尾までを読み込みます。 + ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 + 1 + + + UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + + が書き込み可能ではありません。 + + は null です。 + + + 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + + または が null です。 + + が書き込み可能ではありません。 + + + 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + true to leave the stream open after the object is disposed; otherwise, false. + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + + が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 + + に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 + 1 + + + バッキング ストアと連結する、基になるストリームを取得します。 + この StreamWriter が書き込むストリーム。 + 2 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + + + 出力の書き込みに使用する を取得します。 + 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 + 2 + + + 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 + 現在のライターがクローズされています。 + I/O エラーが発生しました。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + 1 + + + このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 + 1 + + + ストリームに文字を書き込みます。 + ストリームに書き込む文字。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列を書き込みます。 + 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列の一部を書き込みます。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字列を書き込みます。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + I/O エラーが発生しました。 + 1 + + + 文字を非同期でストリームに書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列から読み取る を実装します。 + 2 + + + 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 + + を初期化する目的の文字列。 + + パラメーターが null です。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 + 基になる文字列の次の文字。または使用できる文字がない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 + バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + バッファー内の開始インデックス。 + 読み取る文字の数。 + + は null なので、 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + 現在のリーダーが閉じています。 + 2 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 + 現在の文字列の次の行。文字列の末尾に到達した場合は null。 + 現在のリーダーが閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 2 + + + 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 + 基になる文字列の現在位置から末尾までの内容。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 現在のリーダーが閉じています。 + 2 + + + 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + + は null なので、 + + + 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + 書式を制御する オブジェクト。 + + は null なので、 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 出力の書き込みに使用する を取得します。 + 出力の書き込み時に適用する Encoding。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + + + 基になる を返します。 + 基になる StringBuilder。 + 2 + + + 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 + 現在の StringWriter に書き込まれた文字を格納している文字列。 + 2 + + + 文字列に文字を書き込みます。 + 書き込む文字。 + ライターが閉じられました。 + 2 + + + 文字配列の一部を文字列に書き込みます。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + または が負の値です。 + ( + )> 。Length. + ライターが閉じられました。 + 2 + + + 現在の文字列に文字列を書き込みます。 + 書き込む文字列。 + ライターが閉じられました。 + 2 + + + 文字列に文字を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に文字列を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 一連の文字を読み取ることができるリーダーを表します。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り対象のデータを TextReader に提供しません。 + 1 + + + リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 + テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 2 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 + リーダーの次の行。またはすべての文字が読み取られた場合は null。 + I/O エラーが発生しました。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + + が閉じています。 + 次の行の文字数が、 を超えています。 + 1 + + + 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 + テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 + I/O エラーが発生しました。 + + が閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 次の行の文字数が、 を超えています。 + 1 + + + テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + この TextWriter で使用する改行文字を格納します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 + 出力の書き込み時に適用する文字エンコーディング。 + 1 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + テキスト ライターは破棄されます。 + ライターは現在、前の書き込み操作で使用中です。 + + + 書式を制御するオブジェクトを取得します。 + 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 + 2 + + + 現在の TextWriter で使用される行終端文字列を取得または設定します。 + 現在の TextWriter で使用する行終端文字列。 + 2 + + + バッキング ストアを持たない書き込み専用の TextWriter を提供します。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字配列をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込みます。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込むオブジェクト。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込みます。 + 書き込む文字列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + + または が null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をテキスト文字列またはストリームに書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + データの読み込みを開始する、 内の文字の位置。 + 書き込む文字の最大数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + 文字列またはオブジェクトが null として渡されました。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml new file mode 100644 index 00000000..145ab498 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml @@ -0,0 +1,2262 @@ + + + + System.IO + + + + 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. + 2 + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 가 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 또는 가 null인 경우 + + + + 의 내부 스트림에 대한 액세스를 노출합니다. + BinaryReader와 관련된 내부 스트림입니다. + 2 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. + 읽을 바이트 수입니다. + + 를 읽기 전에 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 요청된 가 내부 버퍼 크기보다 큰 경우 + + + 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. + 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. + 2 + + + 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. + + 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 압축 형식의 32비트 정수를 읽습니다. + 압축 형식의 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 스트림이 손상되었습니다. + + + 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 바이트가 0이 아니면 true이고 0이면 false입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 다음 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. + 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 현재 스트림에서 읽은 문자입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 서로게이트 문자를 읽은 경우 + 2 + + + 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. + 읽을 문자 수입니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 10진 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. + 읽어 오는 문자열입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. + 2 + + + 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 가 null입니다. + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + + 의 내부 스트림을 가져옵니다. + BinaryWriter와 관련된 내부 스트림입니다. + 1 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 1 + + + 백업 저장소가 없는 를 지정합니다. + 1 + + + 내부 스트림을 보유합니다. + + + 현재 스트림 내에서 위치를 설정합니다. + 현재 스트림에서의 위치입니다. + + 에 상대적인 바이트 오프셋입니다. + 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. + 파일 포인터가 잘못된 위치로 이동한 경우 + + 값이 잘못된 경우 + 1 + + + false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. + 쓸 Boolean 값(0 또는 1)입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 없는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 내부 스트림에 바이트 배열을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 null입니다. + 1 + + + 현재 스트림에 바이트 배열 영역을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 단일 서로게이트 문자인 경우 + 1 + + + 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + + 가 null입니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. + 출력할 10진수 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 있는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + + 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 값입니다. + I/O 오류가 발생하는 경우 + + 가 null입니다. + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 압축 형식의 32비트 정수를 씁니다. + 쓸 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + 스트림이 닫혀 있는 경우 + + + 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. + 2 + + + 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + + 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 현재 스트림을 만들 부호 없는 바이트의 배열입니다. + + 가 null인 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + + 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + + 가 null인 경우 + + 또는 가 0보다 작은 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 내부 배열의 초기 크기(바이트)입니다. + + 가 음수인 경우 + + + 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 2 + + + 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. + 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. + 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 + 현재 스트림이 닫혀 있는 경우 + 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 + 2 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. + 취소 요청을 모니터링할 토큰입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다. + 스트림이 삭제된 경우 + + + 스트림의 길이(바이트)를 가져옵니다. + 스트림의 길이(바이트)입니다. + 스트림이 닫혀 있는 경우 + 2 + + + 스트림 내의 현재 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + 위치가 음수 값이나 보다 큰 값으로 설정된 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. + 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. + 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트를 읽습니다. + + 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림 내의 위치를 지정된 값으로 설정합니다. + 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. + 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. + 검색 참조 지점 역할을 하는 형식의 값입니다. + 스트림의 시작 전에 검색하려고 한 경우 + + 가 보다 큰 경우 + 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림의 길이를 지정된 값으로 설정합니다. + 길이를 설정할 값입니다. + 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 + + 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. + 2 + + + + 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. + 새 바이트 배열입니다. + 2 + + + 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. + 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. + 이 스트림을 만든 바이트 배열 세그먼트입니다. + + + 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. + 데이터를 쓸 버퍼입니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 위치에서 현재 스트림에 바이트를 씁니다. + 쓸 바이트입니다. + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 + 현재 스트림이 닫혀 있는 경우 + 2 + + + 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. + 이 메모리 스트림을 쓸 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 닫혀 있는 경우 + 2 + + + 탐색에 사용할 스트림 내 위치를 지정합니다. + 2 + + + 스트림의 맨 앞을 지정합니다. + + + 스트림 내의 현재 위치를 지정합니다. + + + 스트림의 맨 끝을 지정합니다. + + + 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. + 2 + + + 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 에서 사용하는 모든 리소스를 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. + I/O 오류가 발생하는 경우 + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + 스트림이 삭제된 경우 + + + 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. + 스트림 길이(바이트)를 나타내는 long 값입니다. + Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 백업 저장소가 없는 Stream입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + I/O 오류가 발생하는 경우 + 스트림이 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. + 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. + 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에서 읽을 최대 바이트 수입니다. + + 와 의 합계가 버퍼 길이보다 큰 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. + Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. + 현재 스트림 내의 새 위치입니다. + + 매개 변수에 상대적인 바이트 오프셋입니다. + 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. + 원하는 현재 스트림의 길이(바이트)입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. + 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에 쓸 바이트 수입니다. + 총  및  버퍼 길이 보다 큽니다. + + null입니다. + + 또는  음수입니다. + 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. + 스트림이 쓰기를 지원하지 않습니다. + + 스트림이 닫힌 후 호출 되었습니다. + 1 + + + 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. + 스트림에 쓸 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 1 + + + 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + 최소 버퍼 크기입니다. + 스트림이 읽기를 지원하지 않습니다. + + 또는 가 null인 경우 + + 가 0보다 작거나 같은 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. + 최소 버퍼 크기입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + + + 내부 스트림을 반환합니다. + 내부 스트림입니다. + 2 + + + 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. + 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. + 2 + + + 내부 버퍼를 지웁니다. + 2 + + + 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. + 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. + 내부 스트림이 삭제된 경우 + 1 + + + 빈 스트림 주위의 개체입니다. + 1 + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + + 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. + 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 인덱스입니다. + 읽을 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫히는 등의 I/O 오류가 발생한 경우 + 1 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. + 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + + 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. + 1 + + + UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + + 에 쓸 수 없는 경우 + + 가 null인 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + + 또는 가 null인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + true to leave the stream open after the object is disposed; otherwise, false. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + + 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. + + 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. + 1 + + + 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. + 이 StreamWriter가 쓰고 있는 스트림입니다. + 2 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + + + 출력이 쓰여질 을 가져옵니다. + 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. + 2 + + + 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. + 현재 writer가 닫힌 경우 + I/O 오류가 발생한 경우 + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + 1 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. + 1 + + + 스트림에 문자를 씁니다. + 스트림에 쓸 문자입니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자의 하위 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자열을 씁니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작할 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 줄 종결자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열에서 읽어오는 를 구현합니다. + 2 + + + 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. + + 가 초기화되어야 하는 문자열입니다. + + 매개 변수가 null인 경우 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 버퍼의 시작 인덱스입니다. + 읽을 문자 수입니다. + + 가 null입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. + 현재 판독기가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 2 + + + 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. + 내부 문자열의 현재 위치에서 끝까지의 내용입니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 형식 지정을 제어하는 개체입니다. + + + 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + + 가 null입니다. + + + 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + 형식 지정을 제어하는 개체입니다. + + 가 null입니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 출력이 쓰여질 을 가져옵니다. + 출력이 쓰여질 Encoding입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 비동기 플러시 작업을 나타내는 작업입니다. + + + 내부 를 반환합니다. + 내부 StringBuilder입니다. + 2 + + + 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. + 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. + 2 + + + 문자를 문자열에 씁니다. + 쓸 문자입니다. + 작성기가 닫힌 경우 + 2 + + + 문자의 하위 배열을 문자열에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 또는 가 음수인 경우 + ( + )> 인 경우Length. + 작성기가 닫힌 경우 + 2 + + + 문자를 현재 문자열에 씁니다. + 쓸 문자열입니다. + 작성기가 닫힌 경우 + 2 + + + 문자를 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자를 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + TextReader에 읽을 데이터를 제공하지 않습니다. + 1 + + + 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. + I/O 오류가 발생하는 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + + 가 닫힌 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. + I/O 오류가 발생하는 경우 + + 가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 서식 지정을 제어하는 개체입니다. + + + 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. + 출력을 쓰는 문자 인코딩입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. + + + 서식 지정을 제어하는 개체를 가져옵니다. + 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. + 2 + + + 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. + 현재 TextWriter의 줄 종결자 문자열입니다. + 2 + + + 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. + 1 + + + Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + + 또는 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + 데이터 읽기를 시작하는 의 문자 위치입니다. + 쓸 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + 문자열이나 개체가 null로 전달되는 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml new file mode 100644 index 00000000..d9ad6103 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml @@ -0,0 +1,2023 @@ + + + + System.IO + + + + Считывает примитивные типы данных как двоичные значения в заданной кодировке. + 2 + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Входной поток. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. + Входной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Входной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Параметр или имеет значение null. + + + Предоставляет доступ к базовому потоку объекта . + Базовый поток, связанный с объектом BinaryReader. + 2 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. + Количество байтов, чтение которых необходимо выполнить. + Конец потока достигнут раньше, чем было выполнено чтение байтов. + Ошибка ввода-вывода. + Запрошенное значение превышает размер внутреннего буфера. + + + Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. + Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. + Ошибка ввода-вывода. + Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. + 2 + + + Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. + Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Количество байтов, чтение которых необходимо выполнить. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. + Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Число символов для чтения. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число в сжатом формате. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Поток поврежден. + + + Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. + Значение true, если байт не равен нулю; в противном случае — значение false. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. + Следующий байт, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. + Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. + Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Ошибка ввода-вывода. + Поток закрыт. + Значение отрицательно. + 2 + + + Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Символ, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Выполнено чтение символа-заместителя. + 2 + + + Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. + Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. + Количество символов, которое необходимо считать. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Поток закрыт. + Ошибка ввода-вывода. + Значение отрицательно. + 2 + + + Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. + Десятичное значение, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Число с плавающей запятой длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Целое число со знаком длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. + Байт со знаком, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Число с плавающей запятой длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. + Считываемая строка. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число без знака длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число без знака длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. + Целое число без знака длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. + 2 + + + Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Выходной поток. + Поток не поддерживает запись или был закрыт до начала операции. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. + Выходной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Выходной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Получает базовый поток . + Базовый поток, связанный с объектом BinaryWriter. + 1 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Задает без резервного хранилища. + 1 + + + Содержит базовый поток. + + + Задает позицию в текущем потоке. + Позиция в текущем потоке. + Смещение в байтах относительно . + Поле указывает точку отсчета, относительно которой указывается новая позиция. + Указатель позиции в файле перемещен в недопустимую позицию. + Значение является недопустимым. + 1 + + + Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. + Записываемое в поток значение типа Boolean (0 или 1). + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. + Записываемый в поток байт без знака. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись массива байтов в базовый поток. + Массив байтов, содержащий записываемые в поток данные. + Ошибка ввода-вывода. + Поток закрыт. + Параметр имеет значение null. + 1 + + + Выполняет запись части массива байтов в текущий поток. + Массив байтов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество записываемых байтов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. + Незаменяющий символ Юникода, который необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + + представляет собой единичный символ-заместитель. + 1 + + + Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. + Массив символов, содержащий записываемые в поток данные. + Параметр имеет значение null. + Поток закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. + Массив символов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. + Десятичное значение, которое необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число со знаком размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число со знаком размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число со знаком размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. + Байт со знаком, который необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. + Записываемое значение. + Ошибка ввода-вывода. + Параметр имеет значение null. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число без знака размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число без знака размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число без знака размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число, которое необходимо записать. + Достигнут конец потока. + Поток закрыт. + Поток закрыт. + + + Исключение, которое создается при попытке выполнить чтение за пределами потока. + 2 + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Исключение возникает, когда поток данных имеет недопустимый формат. + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. + Массив байтов без знака, из которого создается текущий поток. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Свойство имеет значение null. + Значение параметра или меньше нуля. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + Параметр или имеет отрицательное значение. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. + Исходный размер внутреннего массива в байтах. + Значение отрицательно. + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 2 + + + Возвращает или задает число байтов, выделенных для этого потока. + Длина применимой к использованию части буфера для потока. + Заданная емкость отрицательная или меньше текущей длины потока. + Текущий поток закрыт. + set вызывается для потока, емкость которого нельзя изменить. + 2 + + + Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля. + Токен для отслеживания запросов отмены. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Переопределяет метод так, что никакие действия не выполняются. + 2 + + + Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены. + Поток был ликвидирован. + + + Возвращает длину потока в байтах. + Длина потока в байтах. + Поток закрыт. + 2 + + + Возвращает или задает текущее положение в потоке. + Текущее положение в потоке. + В качестве положения задано отрицательное значение или значение, большее . + Поток закрыт. + 2 + + + Считывает блок байтов из текущего потока и записывает данные в буфер. + Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. + При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом меньше, чем . + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из текущего потока. + Байт приводится к типу или -1, если достигнут конец потока. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для положения в текущем потоке. + Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. + Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. + Значение типа , которое действует как точка ссылки поиска. + Попытка поиска выполняется до начала потока. + Значение больше значения . + + недопустим. -или-Значение вызвало арифметическое переполнение. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для длины текущего потока. + Значение задаваемой длины. + Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. + Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. + 2 + + + Записывает содержимое потока в массив байтов независимо от свойства . + Новый массив байтов. + 2 + + + Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. + Значение true, если преобразование прошло успешно; в противном случае — значение false. + Сегмент массива байтов, из которого был создан данный поток. + + + Записывает в текущий поток блок байтов, используя данные, считанные из буфера. + Буфер, из которого записываются данные. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. + Длина буфера за вычетом меньше, чем . + Параметр или имеет отрицательное значение. + Ошибка ввода-вывода. + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение текущего потока. + Записываемый байт. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. + Текущий поток закрыт. + 2 + + + Записывает все содержимое данного потока памяти в другой поток. + Поток, в который требуется осуществить запись данного потока памяти. + Свойство имеет значение null. + Текущий или конечный поток закрыт. + 2 + + + Задает позицию в потоке, используемую для поиска. + 2 + + + Задает начало потока. + + + Задает текущее положение в потоке. + + + Задает конец потока. + + + Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса . + + + При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. + Значение true, если поток поддерживает чтение; в противном случае — значение false. + 1 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. + Значение true, если поток поддерживает поиск; в противном случае — значение false. + 1 + + + Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. + Значение, которое показывает, может ли для данного потока истечь время ожидания. + 2 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 1 + + + Считывает байты из текущего потока и записывает их в другой поток. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Поток, в который будет скопировано содержимое текущего потока. + Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает все ресурсы, занятые модулем . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. + Ошибка ввода-вывода. + 2 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Поток был ликвидирован. + + + При переопределении в производном классе получает длину потока в байтах. + Длинное значение, представляющее длину потока в байтах. + Класс, созданный на основе класса Stream, не поддерживает возможность поиска. + Методы были вызваны после закрытия потока. + 1 + + + Объект Stream без резервного хранилища. + 1 + + + При переопределении в производном классе получает или задает позицию в текущем потоке. + Текущее положение в потоке. + Ошибка ввода-вывода. + Этот поток не поддерживает поиск. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. + Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. + Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. + Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. + Максимальное количество байтов, которое должно быть считано из текущего потока. + Сумма значений параметров и больше длины буфера. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 1 + + + Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. + Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + При переопределении в производном классе задает позицию в текущем потоке. + Новая позиция в текущем потоке. + Смещение в байтах относительно параметра . + Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. + Ошибка ввода-вывода. + Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе задает длину текущего потока. + Нужная длина текущего потока в байтах. + Ошибка ввода-вывода. + Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 2 + + + При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. + Массив байтов.Этот метод копирует байты из в текущий поток. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Количество байтов, которое необходимо записать в текущий поток. + Сумма  и  больше, чем длина буфера. + + — null. + + или  является отрицательным. + Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. + Поток не поддерживает запись. + + был вызван после закрытия потока. + 1 + + + Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. + Байт, записываемый в поток. + Ошибка ввода-вывода. + Поток не поддерживает запись или был закрыт до начала операции. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 1 + + + Инициализирует новый экземпляр класса для заданного потока. + Поток, который нужно считать. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. + Поток, который нужно считать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + Минимальный размер буфера. + Поток не поддерживает чтение. + Параметр или имеет значение null. + Значение параметра меньше или равно нулю. + + + Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. + Считываемый поток. + Кодировка символов, которую нужно использовать. + Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. + Минимальный размер буфера. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + + + Возвращает основной поток. + Основной поток. + 2 + + + Возвращает текущую кодировку символов, используемую текущим объектом . + Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. + 2 + + + Очищает внутренний буфер. + 2 + + + Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. + Значение true, если текущее положение находится в конце потока; в противном случае — значение false. + Основной поток удален. + 1 + + + Объект для пустого потока. + 1 + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. + Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. + Ошибка ввода-вывода. + 1 + + + Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. + Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Индекс , с которого требуется начать запись. + Максимальное число считываемых символов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Возникает ошибка ввода-вывода, например закрывается поток. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Произошла ошибка ввода-вывода. + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Следующая строка из входного потока или значение null, если достигнут конец входного потока. + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. + Количество символов в следующей строке больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца потока. + Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. + Количество символов больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. + 1 + + + Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Запись в поток запрещена. + + is null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Значение параметра или — null. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . + Значение true, чтобы заставить сбросить буфер; в противном случае — false. + 1 + + + Получает основной поток, связанный с резервным хранилищем. + Поток, в который StreamWriter выполняет запись. + 2 + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. + 2 + + + Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. + Текущее средство записи закрывается. + Произошла ошибка ввода-вывода. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + 1 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает символ в поток. + Символ, записываемый в поток. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток массив символов. + Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток дочерний массив символов. + Массив символов, содержащий записываемые данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток строку. + Строка, записываемая в поток.Если равняется null, запись не выполняется. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает символ в поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, содержащий записываемые данные. + Положение символа в буфере с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает строку в поток. + Задача, представляющая асинхронную операцию записи. + Строка, записываемая в поток.Если имеет значение null, запись не выполняется. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток признак конца строки. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Реализует класс , осуществляющий чтение из строки. + 2 + + + Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. + Строка, для которой должен быть инициализирован класс . + Значение параметра — null. + + + Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. + Текущее средство чтения закрыто. + 2 + + + Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. + Следующий символ из основной строки или значение -1, если больше нет доступных символов. + Текущее средство чтения закрыто. + 2 + + + Считывает блок символов из строки ввода и увеличивает позицию символов на . + Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Начальный индекс в буфере. + Количество символов, которые необходимо считать. + Параметр имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Следующая строка из текущей строки, или значение null, если достигнут конец строки. + Текущее средство чтения закрыто. + Недостаточно памяти для размещения буфера возвращаемых строк. + 2 + + + Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Содержимое, начиная от текущей позиции до конца основной строки. + Недостаточно памяти для размещения буфера возвращаемых строк. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. + Количество символов больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи данных в строку.Данные хранятся в основном . + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным форматом объекта. + Объект , управляющий форматированием. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . + Класс StringBuilder, в который осуществляется запись. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. + Класс StringBuilder, в который осуществляется запись. + Объект , управляющий форматированием. + Параметр имеет значение null. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Encoding, в которой осуществляется запись выходных данных. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + + + Возвращает основной . + Базовый StringBuilder. + 2 + + + Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. + Строка, содержащая символы, записанные в текущий StringWriter. + 2 + + + Записывает символ в строку. + Символ для записи. + Средство записи закрыто. + 2 + + + Записывает в строку дочерний массив символов. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Значение параметра или является отрицательным. + ( + )> .Length. + Средство записи закрыто. + 2 + + + Записывает строку в текущую строку. + Строка для записи. + Средство записи закрыто. + 2 + + + Выполняет асинхронную запись символа в строку. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в строку. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текущую строку. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в строку символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Представляет средство чтения, позволяющее считывать последовательные наборы символов. + 2 + + + Инициализирует новый экземпляр класса . + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Предоставляет TextReader без данных, доступных для чтения. + 1 + + + Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. + Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. + При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. + Следующая строка из средства чтения, или значение null, если все символы считаны. + Ошибка ввода-вывода. + Недостаточно памяти для размещения буфера возвращаемых строк. + Объект закрыт. + Количество символов в следующей строке больше . + 1 + + + Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. + Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. + Ошибка ввода-вывода. + Объект закрыт. + Недостаточно памяти для размещения буфера возвращаемых строк. + Количество символов в следующей строке больше . + 1 + + + Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. + Количество символов больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса указанным поставщиком формата. + Объект , управляющий форматированием. + + + Сохраняет символы новой строки, используемые для данного TextWriter. + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. + Кодировка символов, в которой осуществляется запись выходных данных. + 1 + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Удалено средство записи текста. + Средство записи в настоящее время используется предыдущей операцией записи. + + + Возвращает объект, управляющий форматированием. + Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. + 2 + + + Возвращает или задает признак конца строки, используемой текущим TextWriter. + Признак конца строки для текущего TextWriter. + 2 + + + Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись символа в текстовую строку или поток. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись массива символов в текстовую строку или поток. + Массив символов, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает дочерний массив символов в текстовую строку или поток. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает текстовое представление десятичного значения в текстовую строку или поток. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. + Записываемый объект. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает строку в текстовую строку или поток. + Строка для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Параметр или имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет асинхронную запись символа в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись массива символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Записывает признак конца строки в текстовую строку или поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Положение символа в , с которого начинается чтение данных. + Наибольшее количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. + Записываемый объект.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток строку, за которой следует признак конца строки. + Строка для записи.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Строка или объект передаются в виде null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает признак конца строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml new file mode 100644 index 00000000..cf7eb52f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml @@ -0,0 +1,2237 @@ + + + + System.IO + + + + 用特定的编码将基元数据类型读作二进制值。 + 2 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输入流。 + 该流不支持读取，为null 或已关闭。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输入流。 + 要使用的字符编码。 + 该流不支持读取，为null 或已关闭。 + + 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输入流。 + 要使用的字符编码。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + 该流不支持读取，为null 或已关闭。 + + 或 为 null。 + + + 公开对 的基础流的访问。 + 与 BinaryReader 关联的基础流。 + 2 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 用从流中读取的指定字节数填充内部缓冲区。 + 要读取的字节数。 + 在可以读取 之前到达了流的末尾。 + 发生 I/O 错误。 + 请求的 大于内部缓冲区大小。 + + + 返回下一个可用的字符，并且不提升字节或字符的位置。 + 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 + 发生 I/O 错误。 + 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 + 2 + + + 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 输入流中的下一个字符，如果当前无可用字符则为 -1。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 从字节数组中的指定点开始，从流中读取指定的字节数。 + 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字节数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从字符数组中的指定点开始，从流中读取指定的字符数。 + 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字符数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 以压缩格式读入 32 位整数。 + 压缩格式的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 流已损坏。 + + + 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 + 如果字节为非零，则为 true，否则为 false。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的下一个字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 + 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 发生 I/O 错误。 + 流已关闭。 + + 为负数。 + 2 + + + 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 从当前流中读取的字符。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 读取了一个代理项字符。 + 2 + + + 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 + 要读取的字符数。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 流已关闭。 + 发生 I/O 错误。 + + 为负数。 + 2 + + + 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 + 从当前流中读取的十进制数值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的一个有符号字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 4 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 + 正被读取的字符串。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 + 从该流中读取的 2 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 + 从该流中读取的 4 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 + 从该流中读取的 8 字节无符号整数。 + 已到达流的末尾。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 + 2 + + + 初始化向流中写入的 类的新实例。 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输出流。 + 该流不支持写入或者该流已关闭。 + + 为 null。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输出流。 + 要使用的字符编码。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输出流。 + 要使用的字符编码。 + 如果在释放 对象之后打开流对象，则为 true；否则为， false。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 获取 的基础流。 + 与 BinaryWriter 关联的基础流。 + 1 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 指定无后备存储区的 。 + 1 + + + 持有基础流。 + + + 设置当前流中的位置。 + 包含当前流的位置。 + 相对于 的字节偏移量。 + + 的一个字段，指示获取新位置所依据的参考点。 + 文件指针被移到无效位置。 + + 值无效。 + 1 + + + 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 + 要写入的 Boolean 值（0 或 1）。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的无符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将字节数组写入基础流。 + 包含要写入的数据的字节数组。 + 发生 I/O 错误。 + 流已关闭。 + + 为 null。 + 1 + + + 将字节数组部分写入当前流。 + 包含要写入的数据的字节数组。 + + 中开始写入的起始点。 + 要写入的字节数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 要写入的非代理项 Unicode 字符。 + 发生 I/O 错误。 + 流已关闭。 + + 是单一代理项字符。 + 1 + + + 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 为 null。 + 流已关闭。 + 发生 I/O 错误。 + 1 + + + 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 中开始写入的起始点。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个十进制值写入当前流，并将流位置提升十六个字节。 + 要写入的十进制值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的有符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 + 要写入的值。 + 发生 I/O 错误。 + + 为 null。 + 流已关闭。 + 1 + + + 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 以压缩格式写出 32 位整数。 + 要写出的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 流已关闭。 + + + 读操作试图超出流的末尾时引发的异常。 + 2 + + + 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + + + 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 在数据流的格式无效时引发的异常。 + + + 初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 用对作为此异常原因的内部异常的引用初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化为零的可扩展容量初始化 类的新实例。 + + + 基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建当前流的无符号字节数组。 + + 为 null。 + + + 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + + 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 为 null。 + + 或 小于零。 + 缓冲区长度减去 小于 。 + + + 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 使用按指定要求初始化的可扩展容量初始化 类的新实例。 + 内部数组的初始大小（以字节为单位）。 + + 为负数。 + + + 获取一个值，该值指示当前流是否支持读取。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持查找。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持写入。 + 如果流支持写入，则为 true；否则为 false。 + 2 + + + 获取或设置分配给该流的字节数。 + 流的缓冲区的可使用部分的长度。 + 容量设置为负或小于流的当前长度。 + 当前流已关闭。 + 对不能修改其容量的流调用 set。 + 2 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。 + 要监视取消请求的标记。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 重写 方法以便不执行任何操作。 + 2 + + + 异步清除此流的所有缓冲区，并监视取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。 + 流已被释放。 + + + 获取流的长度（以字节为单位）。 + 流的长度（以字节为单位）。 + 流已关闭。 + 2 + + + 获取或设置流中的当前位置。 + 流中的当前位置。 + 此位置设置为负值或大于 的值。 + 流已关闭。 + 2 + + + 从当前流中读取字节块并将数据写入缓冲区。 + 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 + 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 + + 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 的结果小于 。 + 当前流实例已关闭。 + 2 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流中读取一个字节。 + 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 + 当前流实例已关闭。 + 2 + + + 将当前流中的位置设置为指定值。 + 流内的新位置，通过将初始引用点和偏移量合并计算而得。 + 流内的新位置。它是相对于 参数的位置，而且可正可负。 + 类型 的值，它用作查找引用点。 + 试图在流的开始位置之前查找。 + + 大于 。 + + 无效。- 或 - 导致算法溢出。 + 当前流实例已关闭。 + 2 + + + 将当前流的长度设为指定值。 + 用于设置长度的值。 + 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 + + 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 + 2 + + + 将流内容写入字节数组，而与 属性无关。 + 新的字节数组。 + 2 + + + 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 + 如果转换成功，则为 true；否则为 false。 + 用于创建此流的字节数组段。 + + + 使用从缓冲区读取的数据将字节块写入当前流。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 最多写入的字节数。 + + 为 null。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 + 缓冲区长度减去 的结果小于 。 + + 或 为负。 + 发生 I/O 错误。 + 当前流实例已关闭。 + 2 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入当前位置上的当前流。 + 要写入的字节。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 + 当前流已关闭。 + 2 + + + 将此内存流的整个内容写入到另一个流中。 + 要写入此内存流的流。 + + 为 null。 + 当前流或目标流已关闭。 + 2 + + + 指定在流的位置以查找使用。 + 2 + + + 指定流的开头。 + + + 指定流内的当前位置。 + + + 指定流的结尾。 + + + 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 类的新实例。 + + + 当在派生类中重写时，获取指示当前流是否支持读取的值。 + 如果流支持读取，为 true；否则为 false。 + 1 + + + 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 + 如果流支持查找，为 true；否则为 false。 + 1 + + + 获取一个值，该值确定当前流是否可以超时。 + 一个确定当前流是否可以超时的值。 + 2 + + + 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 + 如果流支持写入，则为 true；否则为 false。 + 1 + + + 从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + 缓冲区的大小。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放由 使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 + 发生 I/O 错误。 + 2 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。默认值为 。 + 流已被释放。 + + + 当在派生类中重写时，获取流长度（以字节为单位）。 + 表示流长度（以字节为单位）的长值。 + 从 Stream 派生的类不支持查找。 + 在流关闭后调用方法。 + 1 + + + 无后备存储区的 Stream。 + 1 + + + 当在派生类中重写时，获取或设置当前流中的位置。 + 流中的当前位置。 + 发生 I/O 错误。 + 流不支持查找。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 + 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 + 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 + + 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 + 要从当前流中最多读取的字节数。 + + 与 的和大于缓冲区长度。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流不支持读取。 + 在流关闭后调用方法。 + 1 + + + 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 + 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 + 流不支持读取。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 + 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 当在派生类中重写时，设置当前流中的位置。 + 当前流中的新位置。 + 相对于 参数的字节偏移量。 + + 类型的值，指示用于获取新位置的参考点。 + 发生 I/O 错误。 + 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，设置当前流的长度。 + 所需的当前流的长度（以字节表示）。 + 发生 I/O 错误。 + 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 2 + + + 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 + 字节数组。此方法将 个字节从 复制到当前流。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 要写入当前流的字节数。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 流不支持写入。 + + 流关闭后调用。 + 1 + + + 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 + 要写入流中的字节。 + 发生 I/O 错误。 + 该流不支持写入，或者该流已关闭。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 + 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 为指定的流初始化 类的新实例。 + 要读取的流。 + + 不支持读取。 + + 为 null。 + + + 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 + 要读取的流。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 为 null。 + + + 用指定的字符编码为指定的流初始化 类的一个新实例。 + 要读取的流。 + 要使用的字符编码。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + 最小缓冲区大小。 + 流不支持读取。 + + 或 为 null。 + + 小于或等于零。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 + 要读取的流。 + 要使用的字符编码。 + 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 + 最小缓冲区大小。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + + + 返回基础流。 + 基础流。 + 2 + + + 获取当前 对象正在使用的当前字符编码。 + 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 + 2 + + + 清除内部缓冲区。 + 2 + + + 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 获取一个值，该值指示当前的流位置是否在流结尾。 + 如果当前流位置位于流的末尾，则为 true；否则为 false。 + 基础流已释放。 + 1 + + + 空流周围的 。 + 1 + + + 返回下一个可用字符，但不使用它。 + 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 + 发生 I/O 错误。 + 1 + + + 读取输入流中的下一个字符并使该字符位置提升一个字符。 + 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 + 发生 I/O 错误。 + 1 + + + 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 + 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 开始写入的 的索引。 + 要读取的最大字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 出现 I/O 错误，如流被关闭。 + 1 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生了 I/O 错误。 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取一行字符并将数据作为字符串返回。 + 输入流中的下一行；如果到达了输入流的末尾，则为 null。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 从当前流中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 + 下一行中的字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取来自流的当前位置到结尾的所有字符。 + 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 + 字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 + 1 + + + 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 + 要写入的流。 + + 不可写。 + + 为 null。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + + 或 为 null。 + + 不可写。 + + + 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + true to leave the stream open after the object is disposed; otherwise, false. + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 + 强制 刷新其缓冲区时，为 true；否则，为 false。 + 1 + + + 获取同后备存储连接的基础流。 + 此 StreamWriter 正在写入的基础流。 + 2 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + 当前编码不支持显示半个 Unicode 代理项对。 + + + 获取将输出写入到其中的 。 + 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 + 2 + + + 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 + 当前编写器已关闭。 + 出现 I/O 错误。 + 当前编码不支持显示半个 Unicode 代理项对。 + 1 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将字符写入流。 + 要写入流中的字符。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符数组写入流。 + 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符的子数组写入流。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符串写入流。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 发生 I/O 错误。 + 1 + + + 将字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将行终止符异步写入该流。 + 表示异步写操作的任务。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 实现从字符串进行读取的 。 + 2 + + + 初始化从指定字符串进行读取的 类的新实例。 + 应将 初始化为的字符串。 + + 参数为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 返回下一个可用的字符，但不使用它。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 + 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的字符块，并将字符位置提升 。 + 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 缓存区中的起始索引。 + 要读取的字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 当前读取器已关闭。 + 2 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前字符串中读取一行字符并将数据作为字符串返回。 + 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 + 当前读取器已关闭。 + 内存不足，无法为返回的字符串分配缓冲区。 + 2 + + + 从当前字符串中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 从当前位置到基础字符串的结尾之间的内容。 + 内存不足，无法为返回的字符串分配缓冲区。 + 当前读取器已关闭。 + 2 + + + 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 + 字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式控制初始化 类的新实例。 + 控制格式设置的 对象。 + + + 初始化写入指定 的 类的新实例。 + 要写入的 StringBuilder。 + + 为 null。 + + + 初始化写入指定 并具有指定格式提供程序的 类的新实例。 + 要写入的 StringBuilder。 + 控制格式设置的 对象。 + + 为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 获取将输出写入到其中的 。 + 用来写入输出的 Encoding。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + + + 返回基础 。 + 基础 StringBuilder。 + 2 + + + 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 + 包含写入到当前 StringWriter 中的字符的字符串。 + 2 + + + 将字符写入该字符串。 + 要写入的字符。 + 编写器已关闭。 + 2 + + + 将字符的子数组写入该字符串。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + 或 为负。 + ( + )> 。Length. + 编写器已关闭。 + 2 + + + 将字符串写入当前流。 + 要写入的字符串。 + 编写器已关闭。 + 2 + + + 以异步方式将字符写入流。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将字符串写入当前流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将后跟行结束符的字符写入该字符串。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将一后跟行结束符的字符串异步写入当前字符串。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 表示可读取有序字符系列的读取器。 + 2 + + + 初始化 类的新实例。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + 提供一个无数据可供读取的 TextReader。 + 1 + + + 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 + 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 + 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 2 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从文本读取器中读取一行字符并将数据作为字符串返回。 + 读取器中的下一行，或为 null （如果已读取了所有字符）。 + 发生 I/O 错误。 + 内存不足，无法为返回的字符串分配缓冲区。 + + 是关闭的。 + 下一行中的字符数大于 + 1 + + + 异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 + 发生 I/O 错误。 + + 是关闭的。 + 内存不足，无法为返回的字符串分配缓冲区。 + 下一行中的字符数大于 + 1 + + + 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 + 字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 表示可以编写一个有序字符系列的编写器。此类为抽象类。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式提供程序初始化 类的新实例。 + 控制格式设置的 对象。 + + + 存储用于此 TextWriter 的换行符。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，返回用来写输出的该字符编码。 + 用来写入输出的字符编码。 + 1 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + 文本编写器已被释放。 + 编写器正在由其前一次写操作使用。 + + + 获取控制格式设置的对象。 + 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 + 2 + + + 获取或设置由当前 TextWriter 使用的行结束符字符串。 + 当前 TextWriter 的行结束符字符串。 + 2 + + + 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符写入该文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符数组写入该文本字符串或流。 + 要写入文本流中的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符的子数组写入文本字符串或流。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符串写入到文本字符串或流。 + 要写入的字符串。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + + 或 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符写入到下一个文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符数组写入到下一个字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符串写入到下一字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将行结束符的字符串写入文本字符串或流。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符写入文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符数组写入文本字符串或流。 + 从其读取数据的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符子数组写入文本字符串或流。 + 从其读取数据的字符数组。 + 在开始读取数据时 中的字符位置。 + 要写入的最大字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符串写入文本字符串或流。 + 要写入的字符串。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + 字符串或对象作为 null 传入。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml new file mode 100644 index 00000000..26192a9d --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml @@ -0,0 +1,2246 @@ + + + + System.IO + + + + 以特定的編碼方式，將基本資料型別當做二進位值讀取。 + 2 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸入資料流。 + 資料流不支援讀取，為 null，或已經關閉。 + + + 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 + 輸入資料流。 + 要使用的字元編碼。 + 資料流不支援讀取，為 null，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + 資料流不支援讀取，為 null，或已經關閉。 + + 或 為 null。 + + + 公開 之基礎資料流的存取。 + 與 BinaryReader 相關聯的基礎資料流。 + 2 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 將從資料流讀取的指定位元組數目填入內部緩衝區。 + 要讀取的位元組數。 + 在 可讀取之前到達資料流末端。 + 發生 I/O 錯誤。 + 所要求的 大於內部緩衝區大小。 + + + 傳回下一個可用字元，而不前移位元組或字元的位置。 + 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 + 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 + 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的位元組數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 由字元陣列中的指定點開始，從資料流讀取指定字元數。 + 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的字元數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以壓縮格式讀取 32 位元整數。 + 壓縮格式的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 資料流已損毀。 + + + 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 + 如果位元組為非零值，則為 true；否則為 false。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 + 自目前資料流讀取的下一個位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 + 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 + 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為負值。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 + 自目前資料流讀取的字元。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 讀取到 Surrogate 字元 + 2 + + + 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 + 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 + 要讀取的字元數。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 已關閉資料流。 + 發生 I/O 錯誤。 + + 為負值。 + 2 + + + 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 + 自目前資料流讀取的十進位值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自目前資料流讀取的 2 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 + 自資料流讀取的帶正負號的位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 + 讀取的字串。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自這個資料流讀取 2 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自這個資料流讀取 4 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自這個資料流讀取 8 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 + 2 + + + 初始化 類別的新執行個體，其將寫入資料流。 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 資料流不支援寫入，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 要使用的字元編碼。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 輸出資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 取得 的基礎資料流。 + 與 BinaryWriter 相關聯的基礎資料流。 + 1 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 指定沒有備份存放區的 。 + 1 + + + 容納基礎資料流。 + + + 設定目前資料流位置。 + 目前資料流的位置。 + 相對於 的位元組位移。 + + 的欄位，表示要取得新位置的參考點。 + 檔案指標已移至無效的位置。 + + 值是無效的。 + 1 + + + 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 + 要寫入的 Boolean 值 (0 或 1)。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的不帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將位元組陣列寫入基礎資料流。 + 含有要寫入之資料的位元組陣列。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為 null。 + 1 + + + 將一個區域的位元組陣列寫入目前資料流。 + 含有要寫入之資料的位元組陣列。 + + 中要開始寫入的起始點。 + 要寫入的位元組數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 非 Surrogate，要寫入的 Unicode 字元。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 是單一 Surrogate 字元。 + 1 + + + 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 為 null。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 中要開始寫入的起始點。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 + 要寫入的十進位值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 要寫入的值。 + 發生 I/O 錯誤。 + + 為 null。 + 已關閉資料流。 + 1 + + + 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組不帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 以壓縮格式寫入 32 位元整數。 + 要寫入的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 已關閉資料流。 + + + 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 + 2 + + + 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + + + 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 資料流在格式無效時擲回的例外狀況。 + + + 初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 + + + 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 + 用於建立目前資料流之不帶正負號位元組的陣列。 + + 為 null。 + + + 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + + 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 為 null。 + + 或 小於零。 + 緩衝區長度減去 小於 。 + + + 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 + 內部陣列的初始大小，以位元組為單位。 + + 為負值。 + + + 取得表示目前資料流是否支援讀取的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援搜尋的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援寫入的值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 2 + + + 取得或設定配置給這個資料流的位元組數目。 + 資料流緩衝區可使用部分的長度。 + 設定的容量為負數或小於資料流目前的長度。 + 目前的資料流已經關閉。 + set 在無法修改其容量的資料流上被叫用 (Invoke)。 + 2 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 + 用來監視是否有取消要求的語彙基元。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 覆寫 方法，以便不執行任何動作。 + 2 + + + 非同步清除這個資料流的所有緩衝區，並監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。 + 已處置資料流。 + + + 取得資料流的長度，以位元組為單位。 + 資料流的長度，以位元組為單位。 + 已關閉資料流。 + 2 + + + 取得或設定資料流中目前的位置。 + 在資料流的目前位置。 + 位置設為負數值或大於 的值。 + 已關閉資料流。 + 2 + + + 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 + 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 + + 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + 緩衝區的長度減去 小於 。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從目前的資料流讀取位元組。 + 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流中的位置設定為指定的數值。 + 資料流中的新位置，是組合初始的參考點和位移計算出來的。 + 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 + + 類型的值，做為搜尋參考點。 + 在資料流開頭之前嘗試搜尋。 + + 大於 。 + 有無效的 。-或- 造成了算術溢位。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流的長度設定為指定的數值。 + 要設定長度的數值。 + 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 + + 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 + 2 + + + 不論 屬性為何，將資料流內容寫入位元組陣列。 + 新的位元組陣列。 + 2 + + + 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 + 如果轉換成功，則為 true；否則為 false。 + 從其中建立此資料流的位元組陣列區段。 + + + 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入的最大位元組數。 + + 為 null。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 + 緩衝區的長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入位元組至資料流目前位置。 + 要寫入的位元組。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 + 目前的資料流已經關閉。 + 2 + + + 將這個記憶體資料流的整個內容寫入另一個資料流。 + 要寫入這個記憶體資料流的資料流。 + + 為 null。 + 目前的資料流或目標資料流已經關閉。 + 2 + + + 指定資料流中要用於搜尋的位置。 + 2 + + + 指定資料流的開端。 + + + 指定資料流中的目前位置。 + + + 指定資料流的末端。 + + + 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 類別的新執行個體。 + + + 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 + 如果資料流支援讀取，則為 true；否則為 false。 + 1 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 + 如果資料流支援搜尋，則為 true；否則為 false。 + 1 + + + 取得值，該值判斷目前的資料流是否可以逾時。 + 值，判斷目前的資料流是否可以逾時。 + 2 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 1 + + + 從目前資料流讀取位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 所使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 發生 I/O 錯誤。 + 2 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 已處置資料流。 + + + 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + 已處置資料流。 + + + 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 + 代表資料流長度的長數值 (以位元組為單位)。 + 衍生自 Stream 的類別不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 沒有底層存放區的 Stream。 + 1 + + + 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 + 在資料流的目前位置。 + 發生 I/O 錯誤。 + 資料流不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 + 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 + 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 + + 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 + 自目前資料流讀取的最大位元組數。 + + 和 的總和大於緩衝區的長度。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 + 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + + 方法必須擲回 。 + 2 + + + 在衍生類別中覆寫時，設定在目前資料流的位置。 + 目前資料流的新位置。 + 相對於 參數的位元組位移。 + + 類型的值，表示用來取得新位置的參考點。 + 發生 I/O 錯誤。 + 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 在衍生類別中覆寫時，設定目前資料流的長度。 + 想要的目前資料流長度 (單位為位元組)。 + 發生 I/O 錯誤。 + 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 + 位元組陣列。此方法會從 複製 位元組到目前資料流。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入目前資料流的位元組數目。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 資料流不支援寫入。 + + 流关闭后调用。 + 1 + + + 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 + 寫入資料流的位元組。 + 發生 I/O 錯誤。 + 資料流不支援寫入，或資料流已經關閉。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + + 方法必須擲回 。 + 2 + + + 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 為指定的資料流，初始化 類別的新執行個體。 + 要讀取的資料流。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + 最小緩衝區大小。 + 資料流不支援讀取。 + + 或 為 null。 + + 小於或等於零值。 + + + 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要讀取的資料流。 + 要使用的字元編碼。 + true 表示在檔案開頭尋找位元順序標記；否則為 false。 + 最小緩衝區大小。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + + 傳回基礎資料流。 + 基礎資料流。 + 2 + + + 取得目前 物件使用的目前字元編碼。 + 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 + 2 + + + 清除內部緩衝區。 + 2 + + + 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得表示現行資料流位置是否在資料流結尾的值。 + 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 + 已處置基礎資料流。 + 1 + + + 空資料流周圍的 物件。 + 1 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 1 + + + 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 + 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 + 發生 I/O 錯誤。 + 1 + + + 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 + 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + 要開始寫入的 的索引。 + 要讀取的字元數上限。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤，例如資料流已經關閉。 + 1 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前資料流讀取一行字元，並將資料以字串傳回。 + 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 + 下一行中的字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到資料流末端的所有字元。 + 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 + 字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 + 1 + + + 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + + 不可寫入。 + + 為 null。 + + + 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + + 或 是 null。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 + 強制 清除其緩衝區，則為 true，否則為 false。 + 1 + + + 取得以備份存放區作介面的基礎資料流。 + StreamWriter 正在寫入的資料流。 + 2 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + + + 取得寫入輸出的 。 + + (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 + 2 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 + 目前寫入器已關閉。 + 發生 I/O 錯誤。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + 1 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + 已處置資料流。 + + + 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將一個字元寫入資料流。 + 要寫入資料流的字元。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元陣列寫入資料流。 + 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元子陣列寫入資料流。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字串寫入資料流。 + 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入資料流。 + 表示非同步寫入作業的工作。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 將行結束字元以非同步方式寫入資料流。 + 表示非同步寫入作業的工作。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 實作讀取字串的 。 + 2 + + + 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 + + 應該初始化的目的字串。 + + 參數為 null。 + + + 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 + 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 + 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + 緩衝區中的起始索引。 + 要讀取的字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負數。 + 目前的讀取器已關閉。 + 2 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前字串讀取一行字元，並將資料以字串傳回。 + 目前字串的下一行，如果已到達字串的結尾，則為 null。 + 目前的讀取器已關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 2 + + + 自目前字串非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 基礎字串從目前位置至結尾的內容。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 目前的讀取器已關閉。 + 2 + + + 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 + 字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的控制項格式，初始化 類別的新執行個體。 + 控制格式的 物件。 + + + 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 + 要寫入至其中的 StringBuilder。 + + 為 null。 + + + 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 + 要寫入至其中的 StringBuilder。 + 控制格式的 物件。 + + 為 null。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得寫入輸出的 。 + 寫入輸出的 Encoding。 + 1 + + + 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + + + 傳回基礎 。 + 基礎 StringBuilder。 + 2 + + + 傳回字串，包含被寫入至目前 StringWriter 的字元。 + 字串，包含被寫入至目前 StringWriter 的字元。 + 2 + + + 將一個字元寫入至字串。 + 要寫入的字元。 + 寫入器關閉。 + 2 + + + 將字元子陣列寫入至字串。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 或 為負數。 + ( + )> 。Length. + 寫入器關閉。 + 2 + + + 將字串寫入至目前字串。 + 要寫入的字串。 + 寫入器關閉。 + 2 + + + 以非同步方式將字元寫入至字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入至字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入至目前字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 代表可以讀取一連串連續字元的讀取器 (Reader)。 + 2 + + + 初始化 類別的新執行個體。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 提供未讀取資料的 TextReader。 + 1 + + + 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 + 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 2 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自文字讀取器讀取一行字元，並將資料以字串傳回。 + 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 + 發生 I/O 錯誤。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + + 已經關閉。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 字串，包含從目前位置到文字讀取器結尾的所有字元。 + 發生 I/O 錯誤。 + + 已經關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 + 字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的格式提供者，初始化 類別的新執行個體。 + 控制格式設定的 物件。 + + + 儲存這個 TextWriter 所使用的新行字元。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 + 寫入輸出時使用的字元編碼。 + 1 + + + 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 文字寫入器已處置。 + 寫入器目前由先前寫入作業所使用。 + + + 取得控制格式設定的物件。 + 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 + 2 + + + 取得或設定目前 TextWriter 所使用的行結束字元字串。 + 目前 TextWriter 的行結束字元字串。 + 2 + + + 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將 Boolean 值的文字表示寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列寫入到文字字串或資料流。 + 要寫入到文字資料流的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元的子陣列寫入到文字字串或資料流。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 + 要寫入的物件。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串寫入到文字字串或資料流。 + 要寫入的字串。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + + 或 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 將行結束字元寫入到文字字串或資料流。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 中開始讀取資料的字元位置。 + 要寫入的最大字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的物件。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入的字串。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + 傳入的字串或物件為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將行結束字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..97702f121c6806139303d133453c27092e47e89c GIT binary patch literal 30128 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 ATmS$7 literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml new file mode 100644 index 00000000..94677abb --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Reads primitive data types as binary values in a specific encoding. + 2 + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The input stream. + The stream does not support reading, is null, or is already closed. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The input stream. + The character encoding to use. + The stream does not support reading, is null, or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The input stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support reading, is null, or is already closed. + + or is null. + + + Exposes access to the underlying stream of the . + The underlying stream associated with the BinaryReader. + 2 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Fills the internal buffer with the specified number of bytes read from the stream. + The number of bytes to be read. + The end of the stream is reached before could be read. + An I/O error occurs. + Requested is larger than the internal buffer size. + + + Returns the next available character and does not advance the byte or character position. + The next available character, or -1 if no more characters are available or the stream does not support seeking. + An I/O error occurs. + The current character cannot be decoded into the internal character buffer by using the selected for the stream. + 2 + + + Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + The next character from the input stream, or -1 if no characters are currently available. + An I/O error occurs. + The stream is closed. + 2 + + + Reads the specified number of bytes from the stream, starting from a specified point in the byte array. + The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of bytes to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of characters from the stream, starting from a specified point in the character array. + The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of characters to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads in a 32-bit integer in compressed format. + A 32-bit integer in compressed format. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + The stream is corrupted. + + + Reads a Boolean value from the current stream and advances the current position of the stream by one byte. + true if the byte is nonzero; otherwise, false. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the next byte from the current stream and advances the current position of the stream by one byte. + The next byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. + A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. + The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + An I/O error occurs. + The stream is closed. + + is negative. + 2 + + + Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + A character read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + A surrogate character was read. + 2 + + + Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. + A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. + The number of characters to read. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + The stream is closed. + An I/O error occurs. + + is negative. + 2 + + + Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. + A decimal value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. + An 8-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. + A 2-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. + A 4-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. + An 8-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a signed byte from this stream and advances the current position of the stream by one byte. + A signed byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. + A 4-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. + The string being read. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. + A 2-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. + A 4-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. + An 8-byte unsigned integer read from this stream. + The end of the stream is reached. + An I/O error occurs. + The stream is closed. + 2 + + + Writes primitive types in binary to a stream and supports writing strings in a specific encoding. + 2 + + + Initializes a new instance of the class that writes to a stream. + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The output stream. + The stream does not support writing or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The output stream. + The character encoding to use. + The stream does not support writing or is already closed. + + or is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The output stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support writing or is already closed. + + or is null. + + + Gets the underlying stream of the . + The underlying stream associated with the BinaryWriter. + 1 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Specifies a with no backing store. + 1 + + + Holds the underlying stream. + + + Sets the position within the current stream. + The position with the current stream. + A byte offset relative to . + A field of indicating the reference point from which the new position is to be obtained. + The file pointer was moved to an invalid location. + The value is invalid. + 1 + + + Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. + The Boolean value to write (0 or 1). + An I/O error occurs. + The stream is closed. + 1 + + + Writes an unsigned byte to the current stream and advances the stream position by one byte. + The unsigned byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a byte array to the underlying stream. + A byte array containing the data to write. + An I/O error occurs. + The stream is closed. + + is null. + 1 + + + Writes a region of a byte array to the current stream. + A byte array containing the data to write. + The starting point in at which to begin writing. + The number of bytes to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + The non-surrogate, Unicode character to write. + An I/O error occurs. + The stream is closed. + + is a single surrogate character. + 1 + + + Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + A character array containing the data to write. + + is null. + The stream is closed. + An I/O error occurs. + 1 + + + Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. + A character array containing the data to write. + The starting point in from which to begin writing. + The number of characters to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a decimal value to the current stream and advances the stream position by sixteen bytes. + The decimal value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. + The eight-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. + The two-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. + The four-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. + The eight-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a signed byte to the current stream and advances the stream position by one byte. + The signed byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. + The four-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. + The value to write. + An I/O error occurs. + + is null. + The stream is closed. + 1 + + + Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. + The two-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. + The four-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. + The eight-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a 32-bit integer in a compressed format. + The 32-bit integer to be written. + The end of the stream is reached. + The stream is closed. + The stream is closed. + + + The exception that is thrown when reading is attempted past the end of a stream. + 2 + + + Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. + + + Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + The exception that is thrown when a data stream is in an invalid format. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class with an expandable capacity initialized to zero. + + + Initializes a new non-resizable instance of the class based on the specified byte array. + The array of unsigned bytes from which to create the current stream. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. + The array of unsigned bytes from which to create this stream. + The setting of the property, which determines whether the stream supports writing. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + + is null. + + or is less than zero. + The buffer length minus is less than . + + + Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. + The array of unsigned bytes from which to create this stream. + The index in at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + + is null. + + or are negative. + The buffer length minus is less than . + + + Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. + + is null. + + or is negative. + The buffer length minus is less than . + + + Initializes a new instance of the class with an expandable capacity initialized as specified. + The initial size of the internal array in bytes. + + is negative. + + + Gets a value indicating whether the current stream supports reading. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports seeking. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 2 + + + Gets or sets the number of bytes allocated for this stream. + The length of the usable portion of the buffer for the stream. + A capacity is set that is negative or less than the current length of the stream. + The current stream is closed. + set is invoked on a stream whose capacity cannot be modified. + 2 + + + Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. + The token to monitor for cancellation requests. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Overrides the method so that no action is performed. + 2 + + + Asynchronously clears all buffers for this stream, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. + The stream has been disposed. + + + Gets the length of the stream in bytes. + The length of the stream in bytes. + The stream is closed. + 2 + + + Gets or sets the current position within the stream. + The current position within the stream. + The position is set to a negative value or a value greater than . + The stream is closed. + 2 + + + Reads a block of bytes from the current stream and writes the data to a buffer. + The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. + When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. + The zero-based byte offset in at which to begin storing data from the current stream. + The maximum number of bytes to read. + + is null. + + or is negative. + + subtracted from the buffer length is less than . + The current stream instance is closed. + 2 + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the current stream. + The byte cast to a , or -1 if the end of the stream has been reached. + The current stream instance is closed. + 2 + + + Sets the position within the current stream to the specified value. + The new position within the stream, calculated by combining the initial reference point and the offset. + The new position within the stream. This is relative to the parameter, and can be positive or negative. + A value of type , which acts as the seek reference point. + Seeking is attempted before the beginning of the stream. + + is greater than . + There is an invalid . -or- caused an arithmetic overflow. + The current stream instance is closed. + 2 + + + Sets the length of the current stream to the specified value. + The value at which to set the length. + The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. + + is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. + 2 + + + Writes the stream contents to a byte array, regardless of the property. + A new byte array. + 2 + + + Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. + true if the conversion was successful; otherwise, false. + The byte array segment from which this stream was created. + + + Writes a block of bytes to the current stream using data read from a buffer. + The buffer to write data from. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + + is null. + The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. + + subtracted from the buffer length is less than . + + or are negative. + An I/O error occurs. + The current stream instance is closed. + 2 + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current stream at the current position. + The byte to write. + The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. + The current stream is closed. + 2 + + + Writes the entire contents of this memory stream to another stream. + The stream to write this memory stream to. + + is null. + The current or target stream is closed. + 2 + + + Specifies the position in a stream to use for seeking. + 2 + + + Specifies the beginning of a stream. + + + Specifies the current position within a stream. + + + Specifies the end of a stream. + + + Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class. + + + When overridden in a derived class, gets a value indicating whether the current stream supports reading. + true if the stream supports reading; otherwise, false. + 1 + + + When overridden in a derived class, gets a value indicating whether the current stream supports seeking. + true if the stream supports seeking; otherwise, false. + 1 + + + Gets a value that determines whether the current stream can time out. + A value that determines whether the current stream can time out. + 2 + + + When overridden in a derived class, gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 1 + + + Reads the bytes from the current stream and writes them to another stream. + The stream to which the contents of the current stream will be copied. + + is null. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + The stream to which the contents of the current stream will be copied. + The size of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Asynchronously reads the bytes from the current stream and writes them to another stream. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + + is null. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + The token to monitor for cancellation requests. The default value is . + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases all resources used by the . + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. + An I/O error occurs. + 2 + + + Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. The default value is . + The stream has been disposed. + + + When overridden in a derived class, gets the length in bytes of the stream. + A long value representing the length of the stream in bytes. + A class derived from Stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + A Stream with no backing store. + 1 + + + When overridden in a derived class, gets or sets the position within the current stream. + The current position within the stream. + An I/O error occurs. + The stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. + An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. + The zero-based byte offset in at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The sum of and is larger than the buffer length. + + is null. + + or is negative. + An I/O error occurs. + The stream does not support reading. + Methods were called after the stream was closed. + 1 + + + Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. + The unsigned byte cast to an Int32, or -1 if at the end of the stream. + The stream does not support reading. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. + A value, in miliseconds, that determines how long the stream will attempt to read before timing out. + The method always throws an . + 2 + + + When overridden in a derived class, sets the position within the current stream. + The new position within the current stream. + A byte offset relative to the parameter. + A value of type indicating the reference point used to obtain the new position. + An I/O error occurs. + The stream does not support seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, sets the length of the current stream. + The desired length of the current stream in bytes. + An I/O error occurs. + The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 2 + + + When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + An array of bytes. This method copies bytes from to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + The sum of  and  is greater than the buffer length. + + is null. + + or  is negative. + An I/O error occured, such as the specified file cannot be found. + The stream does not support writing. + + was called after the stream was closed. + 1 + + + Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current position in the stream and advances the position within the stream by one byte. + The byte to write to the stream. + An I/O error occurs. + The stream does not support writing, or the stream is already closed. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. + A value, in miliseconds, that determines how long the stream will attempt to write before timing out. + The method always throws an . + 2 + + + Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream. + The stream to be read. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. + The stream to be read. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding. + The stream to be read. + The character encoding to use. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + The minimum buffer size. + The stream does not support reading. + + or is null. + + is less than or equal to zero. + + + Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. + The stream to read. + The character encoding to use. + true to look for byte order marks at the beginning of the file; otherwise, false. + The minimum buffer size. + true to leave the stream open after the object is disposed; otherwise, false. + + + Returns the underlying stream. + The underlying stream. + 2 + + + Gets the current character encoding that the current object is using. + The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. + 2 + + + Clears the internal buffer. + 2 + + + Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets a value that indicates whether the current stream position is at the end of the stream. + true if the current stream position is at the end of the stream; otherwise false. + The underlying stream has been disposed. + 1 + + + A object around an empty stream. + 1 + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. + An I/O error occurs. + 1 + + + Reads the next character from the input stream and advances the character position by one character. + The next character from the input stream represented as an object, or -1 if no more characters are available. + An I/O error occurs. + 1 + + + Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. + The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The index of at which to begin writing. + The maximum number of characters to read. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs, such as the stream is closed. + 1 + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurred. + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current stream and returns the data as a string. + The next line from the input stream, or null if the end of the input stream is reached. + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads a line of characters asynchronously from the current stream and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the stream. + The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. + The number of characters is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. + The stream to write to. + + is not writable. + + is null. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. + The stream to write to. + The character encoding to use. + + or is null. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + + or is null. + + is negative. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + true to leave the stream open after the object is disposed; otherwise, false. + + or is null. + + is negative. + + is not writable. + + + Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . + true to force to flush its buffer; otherwise, false. + 1 + + + Gets the underlying stream that interfaces with a backing store. + The stream this StreamWriter is writing to. + 2 + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + The current encoding does not support displaying half of a Unicode surrogate pair. + + + Gets the in which the output is written. + The specified in the constructor for the current instance, or if an encoding was not specified. + 2 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. + The current writer is closed. + An I/O error has occurred. + The current encoding does not support displaying half of a Unicode surrogate pair. + 1 + + + Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Provides a StreamWriter with no backing store that can be written to, but not read from. + 1 + + + Writes a character to the stream. + The character to write to the stream. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a character array to the stream. + A character array containing the data to write. If is null, nothing is written. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a subarray of characters to the stream. + A character array that contains the data to write. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The buffer length minus is less than . + + or is negative. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a string to the stream. + The string to write to the stream. If is null, nothing is written. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + An I/O error occurs. + 1 + + + Writes a character to the stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the stream asynchronously. + A task that represents the asynchronous write operation. + A character array that contains the data to write. + The character position in the buffer at which to begin reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string to the stream asynchronously. + A task that represents the asynchronous write operation. + The string to write to the stream. If is null, nothing is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Implements a that reads from a string. + 2 + + + Initializes a new instance of the class that reads from the specified string. + The string to which the should be initialized. + The parameter is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. + The current reader is closed. + 2 + + + Reads the next character from the input string and advances the character position by one character. + The next character from the underlying string, or -1 if no more characters are available. + The current reader is closed. + 2 + + + Reads a block of characters from the input string and advances the character position by . + The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The starting index in the buffer. + The number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The current reader is closed. + 2 + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current string and returns the data as a string. + The next line from the current string, or null if the end of the string is reached. + The current reader is closed. + There is insufficient memory to allocate a buffer for the returned string. + 2 + + + Reads a line of characters asynchronously from the current string and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the string and returns them as a single string. + The content from the current position to the end of the underlying string. + There is insufficient memory to allocate a buffer for the returned string. + The current reader is closed. + 2 + + + Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. + The number of characters is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing information to a string. The information is stored in an underlying . + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format control. + An object that controls formatting. + + + Initializes a new instance of the class that writes to the specified . + The StringBuilder to write to. + + is null. + + + Initializes a new instance of the class that writes to the specified and has the specified format provider. + The StringBuilder to write to. + An object that controls formatting. + + is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the in which the output is written. + The Encoding in which the output is written. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + + + Returns the underlying . + The underlying StringBuilder. + 2 + + + Returns a string containing the characters written to the current StringWriter so far. + The string containing the characters written to the current StringWriter. + 2 + + + Writes a character to the string. + The character to write. + The writer is closed. + 2 + + + Writes a subarray of characters to the string. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + + or is negative. + ( + )> . Length. + The writer is closed. + 2 + + + Writes a string to the current string. + The string to write. + The writer is closed. + 2 + + + Writes a character to the string asynchronously. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the string asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string to the current string asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the current string. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Represents a reader that can read a sequential series of characters. + 2 + + + Initializes a new instance of the class. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Provides a TextReader with no data to read from. + 1 + + + Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. + An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. + The is closed. + An I/O error occurs. + 1 + + + Reads the next character from the text reader and advances the character position by one character. + The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 2 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the text reader and returns the data as a string. + The next line from the reader, or null if all characters have been read. + An I/O error occurs. + There is insufficient memory to allocate a buffer for the returned string. + The is closed. + The number of characters in the next line is larger than + 1 + + + Reads a line of characters asynchronously and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. + The number of characters in the next line is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the text reader and returns them as one string. + A string that contains all characters from the current position to the end of the text reader. + An I/O error occurs. + The is closed. + There is insufficient memory to allocate a buffer for the returned string. + The number of characters in the next line is larger than + 1 + + + Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. + The number of characters is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Represents a writer that can write a sequential series of characters. This class is abstract. + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format provider. + An object that controls formatting. + + + Stores the newline characters used for this TextWriter. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, returns the character encoding in which the output is written. + The character encoding in which the output is written. + 1 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The text writer is disposed. + The writer is currently in use by a previous write operation. + + + Gets an object that controls formatting. + An object for a specific culture, or the formatting of the current culture if no other culture is specified. + 2 + + + Gets or sets the line terminator string used by the current TextWriter. + The line terminator string for the current TextWriter. + 2 + + + Provides a TextWriter with no backing store that can be written to, but not read from. + 1 + + + Writes the text representation of a Boolean value to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a character array to the text string or stream. + The character array to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters to the text string or stream. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte floating-point value to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object to the text string or stream by calling the ToString method on that object. + The object to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string to the text string or stream. + The string to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + + or is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character array to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If is null, nothing is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a line terminator to the text string or stream. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character followed by a line terminator to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes an array of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The character position in at which to start reading data. + The maximum number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value followed by a line terminator to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. + The object to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string followed by a line terminator to the text string or stream. + The string to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + A string or object is passed in as null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes an array of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If the character array is null, only the line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml new file mode 100644 index 00000000..07b2661f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. + 2 + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. + Der Eingabestream. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + oder ist null. + + + Gewährt Zugriff auf den zugrunde liegenden Stream von . + Der BinaryReader zugeordnete, zugrunde liegende Stream. + 2 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. + Die Anzahl der zu lesenden Bytes. + Das Ende des Streams ist erreicht, bevor gelesen werden konnte. + E/A-Fehler. + Die angeforderten überschreiten die interne Puffergröße. + + + Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. + Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. + 2 + + + Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. + Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Bytes. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 32-Bit-Ganzzahl in komprimiertem Format. + Eine 32-Bit-Ganzzahl in komprimiertem Format. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Der Datenstrom ist beschädigt. + + + Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + true, wenn das Byte ungleich 0 (null) ist, andernfalls false. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + Das nächste aus dem aktuellen Stream gelesene Byte. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. + Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + E/A-Fehler. + Der Stream ist geschlossen. + + ist negativ. + 2 + + + Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein aus dem aktuellen Stream gelesenes Zeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Ein Ersatzzeichenzeichen wurde gelesen. + 2 + + + Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Zeichen. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + Der Stream ist geschlossen. + E/A-Fehler. + + ist negativ. + 2 + + + Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. + Ein aus dem aktuellen Stream gelesener Dezimalwert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. + Die gelesene Zeichenfolge. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. + Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. + Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. + 2 + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. + + + Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. + Der Ausgabestream. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Ruft den zugrunde liegenden Stream von ab. + Der BinaryWriter zugeordnete, zugrunde liegende Stream. + 1 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Gibt eine -Klasse ohne Sicherungsspeicher an. + 1 + + + Enthält den zugrunde liegenden Stream. + + + Legt die Position im aktuellen Stream fest. + Die Position im aktuellen Stream. + Ein Byteoffset im Verhältnis zu . + Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. + Der Dateizeiger wurde an eine ungültige Position verschoben. + Der -Wert ist ungültig. + 1 + + + Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. + Der zu schreibende Boolean-Wert (0 (null) oder 1). + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Bytearray in den zugrunde liegenden Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + E/A-Fehler. + Der Stream ist geschlossen. + + ist null. + 1 + + + Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Bytes. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). + E/A-Fehler. + Der Stream ist geschlossen. + + ist ein einzelnes Ersatzzeichen. + 1 + + + Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + + ist null. + Der Stream ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. + Der zu schreibende Dezimalwert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Der zu schreibende 8-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Der zu schreibende 4-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. + Der zu schreibende Wert. + E/A-Fehler. + + ist null. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. + Die zu schreibende 32-Bit-Ganzzahl. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + Der Stream ist geschlossen. + + + Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. + 2 + + + Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. + + + Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. + + ist null. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + + Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + + ist null. + + oder ist kleiner als 0. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , bei dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. + Die Anfangsgröße des internen Arrays in Bytes. + + ist negativ. + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 2 + + + Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. + Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. + Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. + Der aktuelle Stream ist geschlossen. + set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. + 2 + + + Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. + Das Token zum überwachen von Abbruchanforderungen . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen . + Der Stream wurde freigegeben. + + + Ruft die Länge des Streams in Bytes ab. + Die Länge des Streams in Bytes. + Der Stream ist geschlossen. + 2 + + + Ruft die aktuelle Position im Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. + Der Stream ist geschlossen. + 2 + + + Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. + Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. + Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + + subtrahiert von der Pufferlänge ist kleiner als . + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem aktuellen Stream. + Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Position im aktuellen Stream auf den angegebenen Wert fest. + Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. + Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. + Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. + Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. + + ist größer als . + Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. + Der Wert, auf den die Länge festgelegt werden soll. + Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. + + ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. + 2 + + + Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. + Ein neues Bytearray. + 2 + + + Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. + true, wenn die Konvertierung erfolgreich war, andernfalls false. + Das Bytearraysegment, aus dem der Stream erstellt wurde. + + + Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. + + subtrahiert von der Pufferlänge ist kleiner als . + + oder ist negativ. + E/A-Fehler. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuelle Position im aktuellen Stream. + Das zu schreibende Byte. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. + Der aktuelle Stream ist geschlossen. + 2 + + + Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. + Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. + + ist null. + Der aktuelle Stream oder der Zielstream ist geschlossen. + 2 + + + Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. + 2 + + + Gibt den Anfang eines Streams an. + + + Gibt die aktuelle Position innerhalb eines Streams an. + + + Gibt das Ende eines Streams an. + + + Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. + 1 + + + Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + 2 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 1 + + + Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt alle vom verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + E/A-Fehler. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + Der Stream wurde freigegeben. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. + Ein Long-Wert, der die Länge des Streams in Bytes darstellt. + Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Ein Stream ohne Sicherungsspeicher. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. + Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. + Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. + Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. + Die Summe aus und ist größer als die Pufferlänge. + + ist null. + + oder ist negativ. + E/A-Fehler. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. + Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. + Die neue Position innerhalb des aktuellen Streams. + Ein Byteoffset relativ zum -Parameter. + Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. + Die gewünschte Länge des aktuellen Streams in Bytes. + E/A-Fehler. + Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. + Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. + Die Summe der  und  ist größer als die Länge des Puffers. + + ist null. + + oder  ist negativ. + E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. + Der Stream unterstützt das Schreiben nicht. + + wurde aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das Byte, das in den Stream geschrieben werden soll. + E/A-Fehler. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Der zu lesende Stream. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + Die Mindestgröße des Puffers. + Lesevorgänge werden vom Stream nicht unterstützt. + + oder ist null. + + ist kleiner oder gleich 0 (null). + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. + Die Mindestgröße des Puffers. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + + Gibt den zugrunde liegenden Stream zurück. + Der zugrunde liegende Stream. + 2 + + + Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. + Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. + 2 + + + Löscht den internen Puffer. + 2 + + + Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. + true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. + Der zugrunde liegende Stream wurde verworfen. + 1 + + + Ein -Objekt um einen leeren Stream. + 1 + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. + E/A-Fehler. + 1 + + + Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. + Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Index von , bei dem mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + Ein E/A-Fehler ist aufgetreten. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. + Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. + Die Anzahl der Zeichen ist niedriger als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + + ist schreibgeschützt. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + + oder ist null. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. + true, um zum Entleeren des Puffers zu zwingen, andernfalls false. + 1 + + + Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. + Der Stream, in den dieser StreamWriter schreibt. + 2 + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. + 2 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. + Der aktuelle Writer wird geschlossen. + Ein E/A-Fehler ist aufgetreten. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + 1 + + + Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt ein Zeichen in den Stream. + Das in den Stream zu schreibende Zeichen. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Zeichenarray in den Stream. + Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Teilarray von Zeichen in den Stream. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt eine Zeichenfolge in den Stream. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Implementiert einen , der aus einer Zeichenfolge liest. + 2 + + + Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. + Die Zeichenfolge, mit der der initialisiert werden soll. + Der -Parameter ist null. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Anfangsindex im Puffer. + Die Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. + Der aktuelle Reader ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + 2 + + + Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. + Die Anzahl der Zeichen ist niedriger als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. + Ein -Objekt zum Steuern der Formatierung. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . + Der StringBuilder, in den geschrieben werden soll. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. + Der StringBuilder, in den geschrieben werden soll. + Ein -Objekt zum Steuern der Formatierung. + + ist null. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die Encoding, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + + + Gibt den zugrunde liegenden zurück. + Der zugrunde liegende StringBuilder. + 2 + + + Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + 2 + + + Schreibt ein Zeichen in die Zeichenfolge. + Das zu schreibende Zeichen. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Teilarray von Zeichen in die Zeichenfolge. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + + oder ist negativ. + ( + )> .Length. + Der Writer ist geschlossen. + 2 + + + Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. + Die zu schreibende Zeichenfolge. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Stellt einen TextReader ohne zu lesende Daten bereit. + 1 + + + Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. + Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 2 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. + E/A-Fehler. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der ist geschlossen. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. + E/A-Fehler. + Der ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. + Die Anzahl der Zeichen ist niedriger als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. + Ein -Objekt zum Steuern der Formatierung. + + + Speichert die für diesen TextWriter verwendeten Zeilenendemarken. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. + Die Zeichencodierung, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Textwriter wird freigegeben. + Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Ruft ein Objekt zum Steuern der Formatierung ab. + Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. + 2 + + + Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. + Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. + 2 + + + Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichenarray. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. + Das zu schreibende Objekt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + + oder ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + Eine Zeichenfolge oder ein Objekt wird als null übergeben. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml new file mode 100644 index 00000000..0b2c206b --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml @@ -0,0 +1,2090 @@ + + + + System.IO + + + + Lee tipos de datos primitivos como valores binarios en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. + La secuencia de entrada. + La secuencia no admite la lectura, es null, o ya está cerrada. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de o es null. + + + Expone el acceso a la secuencia subyacente de . + Secuencia subyacente asociada a BinaryReader. + 2 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. + Número de bytes que se va a leer. + Se llega al final de la secuencia antes de se ha podido leer. + Se produce un error de E/S. + Solicitado es mayor que el tamaño del búfer interno. + + + Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. + Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. + 2 + + + Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. + Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. + Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de bytes que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. + Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de caracteres que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero de 32 bits en formato comprimido. + Entero de 32 bits en formato comprimido. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + La secuencia está dañada. + + + Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Es true si el byte es distinto de cero; en caso contrario, es false. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Siguiente byte que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. + Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. + Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + Se produce un error de E/S. + La secuencia está cerrada. + + es negativo. + 2 + + + Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. + Carácter que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + Se ha leído un carácter suplente. + 2 + + + Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. + Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. + Número de caracteres que se va a leer. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + La secuencia está cerrada. + Se produce un error de E/S. + + es negativo. + 2 + + + Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. + Valor decimal que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. + Valor de punto flotante de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. + Entero con signo de 2 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Entero con signo de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. + Entero con signo de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. + Byte con signo que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Valor de punto flotante de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. + Cadena que se lee. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. + Entero sin signo de 2 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. + Entero sin signo de 4 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. + Entero sin signo de 8 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase que escribe en una secuencia. + + + Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. + Flujo de salida. + La secuencia no admite escritura o ya se encuentra cerrada. + + es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + Flujo de salida. + Codificación de caracteres que se utilizará. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. + Flujo de salida. + Codificación de caracteres que se utilizará. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Obtiene la secuencia subyacente del objeto . + Flujo subyacente asociado a BinaryWriter. + 1 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Especifica un objeto sin memoria auxiliar. + 1 + + + Contiene la secuencia subyacente. + + + Establece la posición en la secuencia actual. + Posición con la secuencia actual. + Desplazamiento de bytes relacionado con . + Un campo de que indica el punto de referencia del que se obtiene la nueva posición. + El puntero de archivo se ha movido a una posición no válida. + El valor de no es válido. + 1 + + + Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. + Valor Boolean que se va a escribir (0 ó 1). + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte sin signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una matriz de bytes en la secuencia subyacente. + Matriz de bytes que contiene los datos que se van a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es null. + 1 + + + Escribe una región de una matriz de bytes en la secuencia actual. + Matriz de bytes que contiene los datos que se van a escribir. + Punto inicial de donde comenzará la escritura. + Número de bytes que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. + El carácter Unicode no suplente que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es un carácter suplente único. + 1 + + + Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + + es null. + La secuencia está cerrada. + Se produce un error de E/S. + 1 + + + Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Punto inicial de donde se empieza a leer. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. + Valor decimal que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Valor de punto flotante de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero con signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero con signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero con signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte con signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Valor de punto flotante de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. + Valor que se va a escribir. + Se produce un error de E/S. + + es null. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero sin signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero sin signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero sin signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero de 32 bits en formato comprimido. + Entero de 32 bits que se va a escribir. + Se llega al final de la secuencia. + La secuencia está cerrada. + La secuencia está cerrada. + + + Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. + 2 + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Excepción que se inicia cuando el formato de un flujo de datos no es válido. + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. + + + Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. + Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + El valor de es null. + + o es menor que cero. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + o son negativos. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. + El valor de es null. + + o es negativo. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. + Tamaño inicial de la matriz interna en bytes. + + es negativo. + + + Obtiene un valor que indica si la secuencia actual admite lectura. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite búsquedas. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 2 + + + Obtiene o establece el número de bytes asignados a esta secuencia. + Longitud de la parte utilizable del búfer para la secuencia. + Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. + La secuencia actual está cerrada. + set se invoca en una secuencia cuya capacidad no se puede modificar. + 2 + + + Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero. + Token para supervisar solicitudes de cancelación. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Reemplaza el método de modo que no se realice ninguna acción. + 2 + + + De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación. + Se ha eliminado la secuencia. + + + Obtiene la longitud de la secuencia en bytes. + Longitud de la secuencia en bytes. + La secuencia está cerrada. + 2 + + + Obtiene o establece la posición actual dentro de la secuencia. + Posición actual dentro de la secuencia. + La posición se establece en un valor negativo o un valor mayor que . + La secuencia está cerrada. + 2 + + + Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. + Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. + Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. + Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + + resta de la longitud del búfer es menor que . + La instancia de la secuencia actual está cerrada. + 2 + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia actual. + El byte convertido en un o -1 si se llega al final de la secuencia. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la posición dentro de la secuencia actual en el valor especificado. + Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. + Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. + Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. + Se ha intentado realizar una búsqueda antes del inicio de la secuencia. + + es mayor que . + Hay un no válido . o bien se produjo un desbordamiento aritmético. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la longitud de la secuencia actual en el valor especificado. + Valor en el que establecer la longitud. + La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. + + es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. + 2 + + + Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . + Nueva matriz de bytes. + 2 + + + Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. + Es true si la conversión se realiza correctamente; en caso contrario, es false. + El segmento de matriz de bytes desde el que se creó esta secuencia. + + + Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número máximo de bytes que se pueden escribir. + El valor de es null. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. + + resta de la longitud del búfer es menor que . + + o son negativos. + Se produce un error de E/S. + La instancia de la secuencia actual está cerrada. + 2 + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte en la posición actual de la secuencia actual. + Byte que se va a escribir. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. + La secuencia actual está cerrada. + 2 + + + Escribe el contenido completo de esta secuencia de memoria en otra secuencia. + Secuencia en la que se va a escribir esta secuencia de memoria. + El valor de es null. + La secuencia actual o de destino está cerrada. + 2 + + + Especifica la posición usada para buscar en una secuencia. + 2 + + + Especifica el comienzo de una secuencia. + + + Especifica lo posición actual dentro de la secuencia. + + + Especifica el final de una secuencia. + + + Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase . + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. + true si la secuencia admite lectura; en caso contrario, false. + 1 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. + true si la secuencia admite búsquedas; en caso contrario, false. + 1 + + + Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + 2 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 1 + + + Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera todos los recursos usados por . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Se produce un error de E/S. + 2 + + + Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + Se ha eliminado la secuencia. + + + Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. + Un valor Long que representa la longitud de la secuencia en bytes. + Una clase derivada de Stream no admite la búsqueda. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Stream sin memoria auxiliar. + 1 + + + Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. + Posición actual dentro de la secuencia. + Se produce un error de E/S. + La secuencia no admite búsquedas. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. + Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. + Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. + Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. + Número máximo de bytes que se deben leer de la secuencia actual. + La suma de y es mayor que la longitud del búfer. + El valor de es null. + + o es negativo. + Se produce un error de E/S. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. + Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. + La nueva posición dentro de la secuencia actual. + Desplazamiento de bytes relacionado con el parámetro . + Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. + Se produce un error de E/S. + La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. + Longitud deseada de la secuencia actual, en bytes. + Se produce un error de E/S. + La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. + Matriz de bytes.Este método copia bytes desde al flujo actual. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número de bytes que se deben escribir en la secuencia actual. + La suma de  y  es mayor que la longitud del búfer. + + es null. + + o  es negativo. + Se produjo un error de E/S, como no se puede encontrar el archivo especificado. + La secuencia no es compatible con la escritura. + + se llama después de cerrar la secuencia. + 1 + + + Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. + Byte que se debe escribir en la secuencia. + Se produce un error de E/S. + La secuencia no admite escritura o ya se encuentra cerrada. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 1 + + + Inicializa una nueva instancia de la clase para el flujo especificado. + Secuencia que se va a leer. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + Tamaño mínimo de búfer. + La secuencia no admite lectura. + El valor de o es null. + + es menor o igual que cero. + + + Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. + Tamaño mínimo de búfer. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + + + Devuelve la secuencia subyacente. + Secuencia subyacente. + 2 + + + Obtiene la codificación de caracteres que actualmente utiliza este objeto . + Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . + 2 + + + Borra el búfer interno. + 2 + + + Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene un valor que indica si la actual posición está al final de la secuencia. + Es true si la actual posición está al final de la secuencia; en caso contrario, es false. + Se ha eliminado la secuencia subyacente. + 1 + + + Objeto en torno a una secuencia vacía. + 1 + + + Devuelve el siguiente carácter disponible pero no lo consume. + Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. + El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. + Se produce un error de E/S. + 1 + + + Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. + Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Índice de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + La longitud del búfer menos es menor que . + El valor de es null. + + o es negativo. + Se produce un error de E/S, como el cierre de la secuencia. + 1 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + + o es negativo. + El se cierra. + Error de E/S. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. + El número de caracteres en la siguiente línea es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la secuencia. + Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. + El número de caracteres es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. + 1 + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + No se puede escribir en . + + is null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + + o es null. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . + Es true para que vacíe su búfer; en caso contrario, es false. + 1 + + + Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. + Secuencia en la que escribe este StreamWriter. + 2 + + + Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. + truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + + + Obtiene el donde se escribe el resultado. + + especificado en el constructor para la instancia actual o si no se ha especificado una codificación. + 2 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. + El sistema de escritura actual está cerrado. + Se produjo un error de E/S. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + 1 + + + Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe un carácter en la secuencia. + Carácter que se va a escribir en la secuencia. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una matriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una submatriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una cadena en la secuencia. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comienza la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Implementa que lee en una cadena. + 2 + + + Inicializa una nueva instancia de la clase que lee en la cadena especificada. + Cadena en la que debe inicializarse. + El parámetro es null. + + + Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Devuelve el siguiente carácter disponible pero no lo consume. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + El sistema de lectura actual está cerrado. + 2 + + + Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. + Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. + El sistema de lectura actual está cerrado. + 2 + + + Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . + Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Índice inicial del búfer. + Número de caracteres que se va a leer. + + es null. + La longitud del búfer menos es menor que . + + o son negativos. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. + El sistema de lectura actual está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + 2 + + + Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Contenido desde la posición actual hasta el final de la cadena subyacente. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. + El número de caracteres es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir información en una cadena.La información se almacena en el subyacente. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Inicializa una nueva instancia de la clase que escribe en el especificado. + Objeto StringBuilder en el que se va a escribir. + + es null. + + + Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. + Objeto StringBuilder en el que se va a escribir. + Objeto que controla las operaciones de formato. + + es null. + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene el donde se escribe el resultado. + Encoding donde se escribe el resultado. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + + + Devuelve el subyacente. + Objeto StringBuilder subyacente. + 2 + + + Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. + Cadena que contiene los caracteres escritos en el StringWriter actual. + 2 + + + Escribe un carácter en la cadena. + Carácter que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe una submatriz de caracteres en la cadena. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + + o son negativos. + ( + ) > .Length. + El sistema de escritura está cerrado. + 2 + + + Escribe una cadena en la cadena actual. + Cadena que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe un carácter en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena actual de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Representa un lector que puede leer una serie secuencial de caracteres. + 2 + + + Inicializa una nueva instancia de la clase . + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. + + + Proporciona un TextReader sin datos del que leer. + 1 + + + Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. + Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. + Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 2 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. + Línea siguiente del lector o null si se han leído todos los caracteres. + Se produce un error de E/S. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El objeto está cerrado. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. + Se produce un error de E/S. + El objeto está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. + El número de caracteres es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Almacena los caracteres de nueva línea usados para el TextWriter. + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. + Codificación de caracteres donde se escriben los resultados. + 1 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se desecha el sistema de escritura de texto. + El sistema de escritura está actualmente en uso por una operación de escritura anterior. + + + Obtiene un objeto que controla las operaciones de formato. + Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. + 2 + + + Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. + Cadena de terminador de línea para el TextWriter actual. + 2 + + + Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. + Objeto que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena en la cadena o secuencia de texto. + Cadena que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + El valor de o es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea en la cadena o secuencia. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + Posición del carácter en donde comenzar a leer datos. + Número máximo de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. + Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. + Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + Una cadena u objeto se pasa como null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml new file mode 100644 index 00000000..30dc29ab --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml @@ -0,0 +1,2201 @@ + + + + System.IO + + + + Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux d'entrée. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + + Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. + Flux d'entrée. + Encodage des caractères à utiliser. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux d'entrée. + Encodage des caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + ou a la valeur null. + + + Expose l'accès au flux sous-jacent de l'élément . + Flux sous-jacent associé à l'élément BinaryReader. + 2 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. + Nombre d'octets à lire. + La fin du flux est atteinte avant que n'ait pu être lu. + Une erreur d'E/S se produit. + + demandé est plus grand que la taille de la mémoire tampon interne. + + + Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. + Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. + 2 + + + Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. + Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre d'octets à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. + Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier 32 bits au format compressé. + Entier 32 bits au format compressé. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Le flux est endommagé. + + + Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. + true si l'octet est différent de zéro ; sinon, false. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. + Octet suivant lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. + Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. + Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Une erreur d'E/S se produit. + Le flux est fermé. + + est négatif. + 2 + + + Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. + Caractère lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Un caractère de substitution a été lu. + 2 + + + Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. + Nombre de caractères à lire. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Le flux est fermé. + Une erreur d'E/S se produit. + + est négatif. + 2 + + + Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. + Valeur décimale lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Valeur à virgule flottante de 8 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. + Entier signé de 2 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Entier signé de 4 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Entier signé de 8 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. + Octet signé lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Valeur à virgule flottante de 4 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. + Chaîne en cours de lecture. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. + Entier non signé de 2 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. + Entier non signé de 4 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. + Entier non signé de 8 octets lu dans ce flux. + La fin du flux est atteinte. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe qui écrit dans un flux. + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux de sortie. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. + Flux de sortie. + Encodage de caractères à utiliser. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux de sortie. + Encodage de caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Obtient le flux sous-jacent de . + Flux sous-jacent associé à BinaryWriter. + 1 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + 1 + + + Spécifie sans magasin de sauvegarde. + 1 + + + Contient le flux sous-jacent. + + + Définit la position dans le flux actuel. + Position dans le flux actuel. + Offset d'octet par rapport à . + Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. + Le pointeur de fichier a été déplacé vers un emplacement non valide. + La valeur n'est pas valide. + 1 + + + Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. + Valeur Boolean à écrire (0 ou 1). + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. + Octet non signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un tableau d'octets dans le flux sous-jacent. + Tableau d'octets contenant les données à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + a la valeur null. + 1 + + + Écrit une zone d'un tableau d'octets dans le flux actuel. + Tableau d'octets contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre d'octets à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Caractère Unicode de non-substitution à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + est un caractère de substitution unique. + 1 + + + Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Tableau de caractères contenant les données à écrire. + + a la valeur null. + Le flux est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. + Tableau de caractères contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. + Valeur décimale à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Valeur à virgule flottante de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. + Octet signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Valeur à virgule flottante de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. + Valeur à écrire. + Une erreur d'E/S se produit. + + a la valeur null. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier non signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier non signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier non signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un nombre entier 32 bits dans un format compressé. + Entier 32 bits à écrire. + La fin du flux est atteinte. + Le flux est fermé. + Le flux est fermé. + + + Exception levée en cas de tentative de lecture au-delà de la fin du flux. + 2 + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Exception qui est levée lorsque le format d'un flux de données n'est pas valide. + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. + Tableau d'octets non signés à partir duquel créer le flux actuel. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + + a la valeur null. + + ou est inférieur à zéro. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. + Taille initiale du tableau interne, en octets. + + est négatif. + + + Obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 2 + + + Obtient ou définit le nombre d'octets alloués pour ce flux. + Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. + La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. + Le flux actuel est fermé. + set est appelé sur un flux dont la capacité ne peut pas être modifiée. + 2 + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. + Jeton pour surveiller les demandes d'annulation. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplace la méthode afin qu'aucune action ne soit effectuée. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation. + Le flux a été supprimé. + + + Obtient la longueur du flux en octets. + Longueur du flux en octets. + Le flux est fermé. + 2 + + + Obtient ou définit la position actuelle dans le flux. + Position actuelle dans le flux. + La position correspond à une valeur négative ou à une valeur supérieure à . + Le flux est fermé. + 2 + + + Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. + Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. + Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + + soustrait à la longueur de la mémoire tampon est inférieur à . + L'instance du flux actuel est fermée. + 2 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet dans le flux actuel. + Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. + L'instance du flux actuel est fermée. + 2 + + + Définit la position dans le flux actuel à la valeur spécifiée. + Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. + Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. + Valeur de type , qui sert de point de référence à la recherche. + Tentative de recherche avant le début du flux. + + est supérieur à . + Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. + L'instance du flux actuel est fermée. + 2 + + + Définit la longueur du flux actuel à la valeur spécifiée. + Valeur à laquelle définir la longueur. + Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. + + est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. + 2 + + + Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . + Nouveau tableau d'octets. + 2 + + + Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. + true si la conversion a réussi ; sinon, false. + Segment de tableau d'octets à partir duquel ce flux a été créé. + + + Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre maximal d'octets à écrire. + + a la valeur null. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. + + soustrait à la longueur de la mémoire tampon est inférieur à . + + ou est négatif. + Une erreur d'E/S se produit. + L'instance du flux actuel est fermée. + 2 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux actuel. + Octet à écrire. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. + Le flux actuel est fermé. + 2 + + + Écrit le contenu complet de ce flux de mémoire dans un autre flux. + Flux dans lequel écrire ce flux de mémoire. + + a la valeur null. + Le flux en cours ou le flux cible est fermé. + 2 + + + Spécifie la position au sein d'un flux à utiliser pour la recherche. + 2 + + + Spécifie le début d'un flux. + + + Spécifie la position actuelle au sein d'un flux. + + + Spécifie la fin d'un flux. + + + Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe . + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux prend en charge la lecture ; sinon, false. + 1 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux prend en charge la recherche ; sinon, false. + 1 + + + Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + 2 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 1 + + + Lit les octets du flux actuel et les écrit dans un autre flux. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Flux vers lequel le contenu du flux actuel sera copié. + Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. + Une erreur d'E/S se produit. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + Le flux a été supprimé. + + + En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. + Valeur de type long représentant la longueur du flux en octets. + Une classe dérivée de Stream ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Élément Stream sans magasin de stockage. + 1 + + + En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. + Position actuelle dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. + Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. + Nombre maximal d'octets à lire dans le flux actuel. + La somme de et de est supérieure à la longueur de la mémoire tampon. + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. + Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. + Nouvelle position dans le flux actuel. + Offset d'octet par rapport au paramètre . + Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. + Longueur souhaitée du flux actuel en octets. + Une erreur d'E/S se produit. + Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. + Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre d'octets à écrire dans le flux actuel. + La somme des  et  est supérieure à la longueur du tampon. + + est null. + + ou  est un nombre négatif. + Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. + Le flux ne prend pas en charge l'écriture. + + a été appelée une fois que le flux a été fermé. + 1 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. + Octet à écrire dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié. + Flux à lire. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. + Flux à lire. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. + Flux à lire. + Encodage des caractères à utiliser. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + Taille minimale de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + + ou a la valeur null. + + est inférieur ou égal à zéro. + + + Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à lire. + Encodage des caractères à utiliser. + true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. + Taille minimale de la mémoire tampon. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + + Retourne le flux sous-jacent. + Flux sous-jacent. + 2 + + + Obtient l'encodage de caractères actuel utilisé par l'objet actuel. + Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . + 2 + + + Efface la mémoire tampon interne. + 2 + + + Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. + true si la position actuelle dans le flux est à la fin du flux ; sinon, false. + Le flux sous-jacent a été supprimé. + 1 + + + Objet autour d'un flux vide. + 1 + + + Retourne le caractère disponible suivant, mais ne le consomme pas. + Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. + Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. + Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Index de auquel commencer l'écriture. + Nombre maximal de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S, telle que la fermeture du flux, se produit. + 1 + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S s'est produite. + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. + Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du flux. + Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. + Le nombre de caractères est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. + Le flux dans lequel écrire. + + n'est pas accessible en écriture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + + ou est null. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . + true pour forcer à vider sa mémoire tampon ; sinon, false. + 1 + + + Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. + Flux dans lequel ce StreamWriter écrit. + 2 + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + + + Obtient le dans lequel la sortie est écrite. + + spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. + 2 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. + Le writer actuel est fermé. + Une erreur d'E/S s'est produite. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + 1 + + + Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. + 1 + + + Écrit un caractère dans le flux. + Caractère à écrire dans le flux. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un sous-tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit une chaîne dans le flux. + Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire où commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire dans le flux.Si est null, rien n'est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un terminateur de ligne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Implémente qui lit une chaîne. + 2 + + + Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. + Chaîne à laquelle doit être initialisé. + Le paramètre est null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Retourne le prochain caractère disponible, mais ne le consomme pas. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Le lecteur actuel est fermé. + 2 + + + Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. + Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. + Le lecteur actuel est fermé. + 2 + + + Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . + Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Index de début dans la mémoire tampon. + Nombre de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Le lecteur actuel est fermé. + 2 + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. + Le lecteur actuel est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + 2 + + + Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. + Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le lecteur actuel est fermé. + 2 + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. + Le nombre de caractères est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. + Objet qui contrôle la mise en forme. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié. + StringBuilder dans lequel écrire. + + a la valeur null. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. + StringBuilder dans lequel écrire. + Objet qui contrôle la mise en forme. + + a la valeur null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le dans lequel la sortie est écrite. + Encoding dans lequel la sortie est écrite. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + + + Retourne le sous-jacent. + StringBuilder sous-jacent. + 2 + + + Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. + Chaîne contenant les caractères écrits dans le StringWriter en cours. + 2 + + + Écrit un caractère dans la chaîne. + Caractère à écrire. + Le writer est fermé. + 2 + + + Écrit un sous-tableau de caractères dans la chaîne. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + ou est négatif. + ( + )> .Length. + Le writer est fermé. + 2 + + + Écrit une chaîne dans la chaîne actuelle. + Chaîne à écrire. + Le writer est fermé. + 2 + + + Écrit un caractère dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans la chaîne actuelle de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Représente un lecteur capable de lire une série séquentielle de caractères. + 2 + + + Initialise une nouvelle instance de la classe . + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Fournit un TextReader sans données à lire. + 1 + + + Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. + Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. + Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. + La ligne suivante du lecteur ou null si tous les caractères ont été lus. + Une erreur d'E/S se produit. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + + est fermé. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. + Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. + Une erreur d'E/S se produit. + + est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. + Le nombre de caractères est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. + Objet qui contrôle la mise en forme. + + + Stocke les caractères de saut de ligne utilisés pour ce TextWriter. + + + Libère toutes les ressources utilisées par l'objet . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. + Encodage de caractères dans lequel la sortie est écrite. + 1 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le writer de texte est supprimé. + Le writer est actuellement utilisé par une opération d'écriture précédente. + + + Obtient un objet qui contrôle la mise en forme. + Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. + 2 + + + Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. + Chaîne de marque de fin de ligne pour le TextWriter actuel. + 2 + + + Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. + Objet à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne dans la chaîne ou le flux de texte. + Chaîne à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + + ou a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + Dans , position de caractère à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + Une chaîne ou un objet est passé en tant que null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml new file mode 100644 index 00000000..46070bec --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml @@ -0,0 +1,2123 @@ + + + + System.IO + + + + Legge i tipi di dati primitivi come valori binari in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. + Flusso di input. + Il flusso non supporta la lettura, è null o è già chiuso. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. + Flusso di input. + Codifica dei caratteri da usare. + Il flusso non supporta la lettura, è null o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. + Flusso di input. + Codifica dei caratteri da usare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la lettura, è null o è già chiuso. + + o è null. + + + Espone l'accesso al flusso sottostante dell'oggetto . + Flusso sottostante associato all'oggetto BinaryReader. + 2 + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Inserisce nel buffer interno il numero specificato di byte letti dal flusso. + Numero di byte da leggere. + È stata raggiunta la fine del flusso prima che fosse possibile leggere . + Si è verificato un errore di I/O. + I richiesti sono superiori alla dimensione del buffer interno. + + + Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. + Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. + 2 + + + Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. + Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. + Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di byte da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. + Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di caratteri da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero a 32 bit in formato compresso. + Intero a 32 bit in formato compresso. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + Flusso danneggiato. + + + Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + true se il byte è diverso da zero; in caso contrario, false. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + Byte successivo letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. + Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. + Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è negativo. + 2 + + + Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Carattere letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + È stato letto un carattere surrogato. + 2 + + + Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. + Numero di caratteri da leggere. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Il flusso è chiuso. + Si è verificato un errore di I/O. + + è negativo. + 2 + + + Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. + Valore decimale letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. + Valore a virgola mobile a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. + Intero con segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Intero con segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. + Intero con segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. + Byte con segno letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Valore a virgola mobile a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. + Stringa da leggere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. + Intero senza segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero senza segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero senza segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe che scrive in un flusso. + + + Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. + Flusso di output. + Il flusso non supporta la scrittura o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. + Flusso di output. + Codifica dei caratteri da utilizzare. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso di output. + Codifica dei caratteri da utilizzare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Ottiene il flusso sottostante dell'oggetto . + Flusso sottostante associato a BinaryWriter. + 1 + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Specifica un oggetto privo di archivio di backup. + 1 + + + Contiene il flusso principale. + + + Imposta la posizione all'interno del flusso corrente. + Posizione all'interno del flusso corrente. + Offset dei byte relativo a . + Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. + Il puntatore a file è stato spostato in un percorso non valido. + Il valore di non è valido. + 1 + + + Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. + Valore Boolean da scrivere (0 o 1). + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una matrice di byte nel flusso sottostante. + Matrice di caratteri che contiene i dati da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è null. + 1 + + + Scrive un'area di una matrice di byte nel flusso corrente. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale nel parametro da cui iniziare la scrittura. + Numero di byte da scrivere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Carattere Unicode non surrogato da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è un carattere surrogato singolo. + 1 + + + Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + + è null. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 1 + + + Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale in dal quale avviare la scrittura. + Numero di caratteri da inserire. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. + Valore decimale da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Valore a virgola mobile a otto byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Valore a virgola mobile a quattro byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. + Valore da scrivere. + Si è verificato un errore di I/O. + + è null. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Inserisce un valore intero a 32 bit in un formato compresso. + Intero da 32 bit da scrivere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Il flusso è chiuso. + + + Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. + 2 + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Eccezione generata se un flusso di dati è in un formato non valido. + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. + Matrice di byte senza segno da cui creare il flusso corrente. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + + è null. + + o è minore di zero. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + o è un valore negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. + + è null. + Il valore di o è negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. + Dimensione iniziale in byte della matrice interna. + + è negativo. + + + Ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 2 + + + Ottiene o imposta il numero di byte allocati per questo flusso. + Lunghezza della parte usabile del buffer per il flusso. + È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. + Il flusso corrente è chiuso. + set è stato richiamato su un flusso del quale non è possibile modificare la capacità. + 2 + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. + Token da monitorare per le richieste di annullamento. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. + 2 + + + Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento. + Il flusso è stato eliminato. + + + Ottiene la lunghezza in byte del flusso. + Lunghezza del flusso in byte. + Il flusso è chiuso. + 2 + + + Ottiene o imposta la posizione corrente all'interno del flusso. + Posizione corrente all'interno del flusso. + La posizione è impostata su un valore negativo o maggiore di . + Il flusso è chiuso. + 2 + + + Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. + Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. + Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. + Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + + sottratto alla lunghezza del buffer è minore di . + L'istanza del flusso corrente è chiusa. + 2 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso corrente. + Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la posizione all'interno del flusso corrente sul valore specificato. + Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. + Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. + Valore di tipo , che funge da punto di riferimento per la ricerca. + La ricerca viene tentata prima dell'inizio del flusso. + + è maggiore di . + Il valore di non è valido. -oppure- causato da un overflow aritmetico. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la lunghezza del flusso corrente sul valore specificato. + Valore su cui impostare la lunghezza. + Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. + + è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. + 2 + + + Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . + Nuova matrice di byte. + 2 + + + Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. + true se la conversione riesce; in caso contrario, false. + Segmento di matrice di byte da cui è stato creato questo flusso. + + + Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero massimo di byte da scrivere. + + è null. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. + + sottratto alla lunghezza del buffer è minore di . + + o è un valore negativo. + Si è verificato un errore di I/O. + L'istanza del flusso corrente è chiusa. + 2 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente all'interno del flusso corrente. + Byte da scrivere. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. + Il flusso corrente è chiuso. + 2 + + + Scrive l'intero contenuto del flusso di memoria in un altro flusso. + Flusso in cui scrivere il flusso di memoria. + + è null. + Il flusso corrente o di destinazione è chiuso. + 2 + + + Specifica la posizione in un flusso da utilizzare per le ricerche. + 2 + + + Specifica l'inizio di un flusso. + + + Specifica la posizione corrente all'interno di un flusso. + + + Specifica la fine di un flusso. + + + Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso supporta la lettura; in caso contrario, false. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso supporta la ricerca; in caso contrario, false. + 1 + + + Ottiene un valore che determina se il flusso corrente prevede il timeout. + Valore che determina se il flusso corrente prevede il timeout. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 1 + + + Legge i byte dal flusso corrente e li scrive in un altro flusso. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Si è verificato un errore di I/O. + 2 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + Il flusso è stato eliminato. + + + Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. + Valore long che rappresenta la lunghezza del flusso in byte. + Una classe derivata da Stream non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Oggetto Stream privo di archivio di backup. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. + Posizione corrente all'interno del flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. + Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. + Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. + Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. + Numero massimo di byte da leggere dal flusso corrente. + La somma di e è maggiore della lunghezza del buffer. + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. + Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. + Nuova posizione all'interno del flusso corrente. + Offset dei byte rispetto al parametro . + Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. + Lunghezza desiderata del flusso corrente in byte. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. + Matrice di byte.Questo metodo copia i byte da nel flusso corrente. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero di byte da scrivere nel flusso corrente. + La somma di  e  è maggiore della lunghezza del buffer. + + è null. + + o  è negativo. + Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. + Il flusso non supporta la scrittura. + + è stato chiamato dopo la chiusura del flusso. + 1 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. + Byte da scrivere nel flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura o è già chiuso. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato. + Flusso da leggere. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. + Flusso da leggere. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. + Flusso da leggere. + Codifica dei caratteri da usare. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + Dimensione minima del buffer. + Il flusso non supporta la lettura. + + o è null. + + è minore o uguale a zero. + + + Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. + Flusso da leggere. + Codifica dei caratteri da usare. + true per cercare i byte order mark all'inizio del file; in caso contrario, false. + Dimensione minima del buffer. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + + Restituisce il flusso sottostante. + Flusso sottostante. + 2 + + + Ottiene la codifica caratteri corrente usata dall'oggetto corrente. + Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . + 2 + + + Cancella il buffer interno. + 2 + + + Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. + true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. + Il flusso sottostante è stato eliminato. + 1 + + + Oggetto che include un flusso vuoto. + 1 + + + Restituisce il carattere successivo disponibile senza usarlo. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. + Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Indice di da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O, come la chiusura del flusso. + 1 + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. + Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. + Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. + Il numero di caratteri è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. + Flusso in cui scrivere. + + non è modificabile. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + + o è null. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + + o è null. + + è negativo. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + o è null. + + è negativo. + + non è modificabile. + + + Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . + true per forzare lo scaricamento del buffer; in caso contrario, false. + 1 + + + Ottiene il flusso sottostante che si interfaccia con un archivio di backup. + Flusso in cui StreamWriter scrive. + 2 + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + + + Ottiene l'oggetto in cui viene scritto l'output. + Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. + 2 + + + Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. + Il writer corrente è chiuso. + Si è verificato un errore di I/O. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive un carattere nel flusso. + Carattere da scrivere nel flusso. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una matrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una sottomatrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una stringa nel flusso. + Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Implementa un oggetto che legge da una stringa. + 2 + + + Inizializza una nuova istanza della classe che legge dalla stringa specificata. + Stringa sulla quale inizializzare . + Il parametro è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Restituisce il carattere successivo disponibile senza utilizzarlo. + Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Il lettore corrente è chiuso. + 2 + + + Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. + Il lettore corrente è chiuso. + 2 + + + Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . + Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Indice iniziale nel buffer. + Numero di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. + Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. + Il lettore corrente è chiuso. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + 2 + + + Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Contenuto dalla posizione corrente alla fine della stringa sottostante. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. + Il numero di caratteri è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il controllo di formato specificato. + Oggetto che controlla la formattazione. + + + Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. + Oggetto StringBuilder in cui scrivere. + + è null. + + + Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. + Oggetto StringBuilder in cui scrivere. + Oggetto che controlla la formattazione. + + è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Recupera l'oggetto in cui viene scritto l'output. + Encoding in cui viene scritto l'output. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di svuotamento asincrona. + + + Restituisce l'oggetto sottostante. + StringBuilder sottostante. + 2 + + + Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. + Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. + 2 + + + Scrive un carattere nella stringa. + Carattere da inserire. + Il writer è chiuso. + 2 + + + Scrive una sottomatrice di caratteri nella stringa. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + Il valore di o è negativo. + ( + )> .Length. + Il writer è chiuso. + 2 + + + Scrive una stringa nella stringa corrente. + Stringa da scrivere. + Il writer è chiuso. + 2 + + + Scrive un carattere nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nella stringa corrente in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. + 2 + + + Inizializza una nuova istanza della classe . + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. + 1 + + + Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. + Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 2 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. + Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. + Si è verificato un errore di I/O. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + La classe è chiusa. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. + Si è verificato un errore di I/O. + La classe è chiusa. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. + Il numero di caratteri è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il provider di formato specificato. + Oggetto che controlla la formattazione. + + + Archivia i caratteri di nuova riga usati per questo TextWriter. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. + Codifica caratteri in cui viene scritto l'output. + 1 + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il writer di testo viene eliminato. + Il writer è attualmente utilizzato da un'operazione di scrittura precedente. + + + Ottiene un oggetto che controlla la formattazione. + Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. + 2 + + + Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. + Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. + 2 + + + Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nella stringa o flusso di testo. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri nella stringa o flusso di testo. + Matrice di caratteri da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. + Oggetto da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa nella stringa o nel flusso di testo. + Stringa da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + + o è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso o nella stringa di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + Posizione del carattere in dalla quale avviare la lettura dei dati. + Numero massimo di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + Viene passato un oggetto o una stringa come null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml new file mode 100644 index 00000000..4114d626 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml @@ -0,0 +1,2264 @@ + + + + System.IO + + + + プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 + 2 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + 使用する文字エンコーディング。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + は null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + または が null です。 + + + + の基になるストリームへのアクセスを公開します。 + BinaryReader に関連付けられた、基になるストリーム。 + 2 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 + 読み取るバイト数。 + + 分のバイトを読み取る前にストリームの末尾に到達しました。 + I/O エラーが発生しました。 + 要求された が、内部バッファー サイズより大きくなっています。 + + + 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 + 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 + 2 + + + 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 + + に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取るバイト数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 + バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取る文字の数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 32 ビット整数を圧縮形式で読み取ります。 + 圧縮形式の 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + ストリームが破損しています。 + + + 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った次のバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 + 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + が負の値です。 + 2 + + + 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 現在のストリームから読み取った文字。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + サロゲート文字が読み取られました。 + 2 + + + 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 + 読み取る文字の数。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + + が負の値です。 + 2 + + + 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 + 現在のストリームから読み取った 10 進数値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った符号付きバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 + 読み取った文字列。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号なし整数。 + ストリームの末尾に到達しました。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 + 2 + + + ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + は null なので、 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + 使用する文字エンコーディング。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 出力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + + の基になるストリームを取得します。 + BinaryWriter に関連付けられた、基になるストリーム。 + 1 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + バッキング ストアを持たない を指定します。 + 1 + + + 基になるストリームを保持します。 + + + 現在のストリーム内の位置を設定します。 + 現在のストリームの位置。 + + からのバイト オフセット。 + 新しい位置を取得するための参照ポイントを示す フィールド。 + ファイル ポインターが無効な位置に移動しました。 + + 値が無効です。 + 1 + + + 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 + 書き込む Boolean 値 (0 または 1)。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号なしバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 基になるストリームにバイト配列を書き込みます。 + 書き込むデータが格納されているバイト配列。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は null なので、 + 1 + + + 現在のストリームにバイト配列の特定の領域を書き込みます。 + 書き込むデータが格納されているバイト配列。 + + 内の書き込み開始点。 + 書き込むバイト数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む非サロゲート Unicode 文字。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は、単一のサロゲート文字です。 + 1 + + + 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + は null なので、 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + 内の書き込み開始点。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 + 書き込む 10 進値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号付きバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む値。 + I/O エラーが発生しました。 + + は null なので、 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 32 ビット整数を圧縮形式で書き込みます。 + 書き込む 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + ストリームが閉じられました。 + + + ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 + 2 + + + メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 + + + メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データ ストリームが無効な形式である場合にスローされる例外。 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 + + + 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + 現在のストリームを作成する符号なしバイトの配列。 + + は null です。 + + + + プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + + バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + + は null です。 + + または が 0 未満です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 + バイト単位の内部配列の初期サイズ。 + + が負の値です。 + + + 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 2 + + + ストリームに割り当てられたバイト数を取得または設定します。 + ストリームに対してバッファーが使用できる部分の長さ。 + 容量が負の値または現在のストリーム長より小さい値に設定されています。 + 現在のストリームが閉じています。 + 容量を変更できないストリームに対して set が呼び出されました。 + 2 + + + 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 + キャンセル要求を監視するためのトークン。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + アクションが実行されないように、 メソッドをオーバーライドします。 + 2 + + + このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。 + ストリームは破棄されています。 + + + バイト単位のストリーム長を取得します。 + バイト単位のストリーム長。 + ストリームが閉じられました。 + 2 + + + ストリームの現在位置を取得または設定します。 + ストリーム内の現在位置。 + 位置が負の値または より大きい値に設定されています。 + ストリームが閉じられました。 + 2 + + + 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 + バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 + このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 + 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームからバイトを読み取ります。 + + にキャストしたバイト。ストリームの末尾に達した場合は -1。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム内の位置を指定した値に設定します。 + 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 + ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 + シーク参照ポイントとして機能する 型の値。 + ストリームの先頭より前をシークしようとしました。 + + が より大きくなっています。 + 無効な があります。または によって算術オーバーフローが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム長を指定した値に設定します。 + 長さを設定する値。 + 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 + + が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 + 2 + + + + プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 + 新しいバイト配列。 + 2 + + + このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 + 変換が成功した場合は true。それ以外の場合は false。 + このストリームの作成元のバイト配列セグメント。 + + + バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 + データの書き込み元となるバッファー。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリーム内の現在位置に 1 バイトを書き込みます。 + 書き込むバイト。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 + 現在のストリームが閉じています。 + 2 + + + メモリ ストリームの内容全体を別のストリームに書き込みます。 + このメモリ ストリームが書き込まれるストリーム。 + + は null です。 + 現在のストリームまたは対象のストリームは閉じています。 + 2 + + + シークに使用するストリームの場所を指定します。 + 2 + + + ストリームの先頭を指定します。 + + + ストリーム内の現在位置を指定します。 + + + ストリームの末尾を指定します。 + + + バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 + ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 + ストリームがシークをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 + 現在のストリームがタイムアウトできるかどうかを決定する値。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + によって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + I/O エラーが発生しました。 + 2 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。既定値は です。 + ストリームは破棄されています。 + + + 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 + ストリーム長 (バイト単位) を表す long 値。 + Stream から派生したクラスがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + バッキング ストアを持たない Stream。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 + ストリーム内の現在位置。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 + バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 + バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 + 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームから読み取る最大バイト数。 + + と の合計値が、バッファー長より大きい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 + Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 + 現在のストリーム内の新しい位置。 + + パラメーターからの相対バイト オフセット。 + 新しい位置を取得するために使用する参照ポイントを示す 型の値。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 + 現在のストリームの希望の長さ (バイト数)。 + I/O エラーが発生しました。 + ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 + バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームに書き込むバイト数。 + 合計  と  がバッファーの長さより大きい。 + + nullです。 + + または  が負の値です。 + 指定したファイルが見つからないなど、I/O エラーが発生しました。 + ストリームは書き込みをサポートしません。 + + ストリームが閉じられた後が呼び出されました。 + 1 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + ストリームに書き込むバイト。 + I/O エラーが発生しました。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 1 + + + 指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + + が読み取りをサポートしていません。 + + は null です。 + + + バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + は null です。 + + + 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + 最小バッファー サイズ。 + ストリームは読み取りをサポートしません。 + + または が null です。 + + が 0 以下です。 + + + 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 読み取るストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 + 最小バッファー サイズ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + + 基になるストリームを返します。 + 基になるストリーム。 + 2 + + + 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 + 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 + 2 + + + 内部バッファーをクリアします。 + 2 + + + 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 + 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 + 基になるストリームは破棄されています。 + 1 + + + 空のストリームの オブジェクト。 + 1 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 + 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 + 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みの開始位置を示す のインデックス。 + 読み取り対象の最大文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。たとえば、ストリームがクローズされています。 + 1 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 + 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + すべての文字の現在位置から末尾までを読み込みます。 + ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 + 1 + + + UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + + が書き込み可能ではありません。 + + は null です。 + + + 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + + または が null です。 + + が書き込み可能ではありません。 + + + 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + true to leave the stream open after the object is disposed; otherwise, false. + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + + が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 + + に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 + 1 + + + バッキング ストアと連結する、基になるストリームを取得します。 + この StreamWriter が書き込むストリーム。 + 2 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + + + 出力の書き込みに使用する を取得します。 + 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 + 2 + + + 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 + 現在のライターがクローズされています。 + I/O エラーが発生しました。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + 1 + + + このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 + 1 + + + ストリームに文字を書き込みます。 + ストリームに書き込む文字。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列を書き込みます。 + 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列の一部を書き込みます。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字列を書き込みます。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + I/O エラーが発生しました。 + 1 + + + 文字を非同期でストリームに書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列から読み取る を実装します。 + 2 + + + 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 + + を初期化する目的の文字列。 + + パラメーターが null です。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 + 基になる文字列の次の文字。または使用できる文字がない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 + バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + バッファー内の開始インデックス。 + 読み取る文字の数。 + + は null なので、 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + 現在のリーダーが閉じています。 + 2 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 + 現在の文字列の次の行。文字列の末尾に到達した場合は null。 + 現在のリーダーが閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 2 + + + 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 + 基になる文字列の現在位置から末尾までの内容。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 現在のリーダーが閉じています。 + 2 + + + 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + + は null なので、 + + + 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + 書式を制御する オブジェクト。 + + は null なので、 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 出力の書き込みに使用する を取得します。 + 出力の書き込み時に適用する Encoding。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + + + 基になる を返します。 + 基になる StringBuilder。 + 2 + + + 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 + 現在の StringWriter に書き込まれた文字を格納している文字列。 + 2 + + + 文字列に文字を書き込みます。 + 書き込む文字。 + ライターが閉じられました。 + 2 + + + 文字配列の一部を文字列に書き込みます。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + または が負の値です。 + ( + )> 。Length. + ライターが閉じられました。 + 2 + + + 現在の文字列に文字列を書き込みます。 + 書き込む文字列。 + ライターが閉じられました。 + 2 + + + 文字列に文字を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に文字列を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 一連の文字を読み取ることができるリーダーを表します。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り対象のデータを TextReader に提供しません。 + 1 + + + リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 + テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 2 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 + リーダーの次の行。またはすべての文字が読み取られた場合は null。 + I/O エラーが発生しました。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + + が閉じています。 + 次の行の文字数が、 を超えています。 + 1 + + + 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 + テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 + I/O エラーが発生しました。 + + が閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 次の行の文字数が、 を超えています。 + 1 + + + テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + この TextWriter で使用する改行文字を格納します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 + 出力の書き込み時に適用する文字エンコーディング。 + 1 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + テキスト ライターは破棄されます。 + ライターは現在、前の書き込み操作で使用中です。 + + + 書式を制御するオブジェクトを取得します。 + 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 + 2 + + + 現在の TextWriter で使用される行終端文字列を取得または設定します。 + 現在の TextWriter で使用する行終端文字列。 + 2 + + + バッキング ストアを持たない書き込み専用の TextWriter を提供します。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字配列をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込みます。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込むオブジェクト。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込みます。 + 書き込む文字列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + + または が null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をテキスト文字列またはストリームに書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + データの読み込みを開始する、 内の文字の位置。 + 書き込む文字の最大数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + 文字列またはオブジェクトが null として渡されました。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml new file mode 100644 index 00000000..145ab498 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml @@ -0,0 +1,2262 @@ + + + + System.IO + + + + 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. + 2 + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 가 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 또는 가 null인 경우 + + + + 의 내부 스트림에 대한 액세스를 노출합니다. + BinaryReader와 관련된 내부 스트림입니다. + 2 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. + 읽을 바이트 수입니다. + + 를 읽기 전에 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 요청된 가 내부 버퍼 크기보다 큰 경우 + + + 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. + 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. + 2 + + + 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. + + 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 압축 형식의 32비트 정수를 읽습니다. + 압축 형식의 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 스트림이 손상되었습니다. + + + 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 바이트가 0이 아니면 true이고 0이면 false입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 다음 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. + 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 현재 스트림에서 읽은 문자입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 서로게이트 문자를 읽은 경우 + 2 + + + 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. + 읽을 문자 수입니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 10진 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. + 읽어 오는 문자열입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. + 2 + + + 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 가 null입니다. + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + + 의 내부 스트림을 가져옵니다. + BinaryWriter와 관련된 내부 스트림입니다. + 1 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 1 + + + 백업 저장소가 없는 를 지정합니다. + 1 + + + 내부 스트림을 보유합니다. + + + 현재 스트림 내에서 위치를 설정합니다. + 현재 스트림에서의 위치입니다. + + 에 상대적인 바이트 오프셋입니다. + 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. + 파일 포인터가 잘못된 위치로 이동한 경우 + + 값이 잘못된 경우 + 1 + + + false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. + 쓸 Boolean 값(0 또는 1)입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 없는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 내부 스트림에 바이트 배열을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 null입니다. + 1 + + + 현재 스트림에 바이트 배열 영역을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 단일 서로게이트 문자인 경우 + 1 + + + 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + + 가 null입니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. + 출력할 10진수 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 있는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + + 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 값입니다. + I/O 오류가 발생하는 경우 + + 가 null입니다. + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 압축 형식의 32비트 정수를 씁니다. + 쓸 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + 스트림이 닫혀 있는 경우 + + + 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. + 2 + + + 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + + 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 현재 스트림을 만들 부호 없는 바이트의 배열입니다. + + 가 null인 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + + 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + + 가 null인 경우 + + 또는 가 0보다 작은 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 내부 배열의 초기 크기(바이트)입니다. + + 가 음수인 경우 + + + 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 2 + + + 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. + 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. + 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 + 현재 스트림이 닫혀 있는 경우 + 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 + 2 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. + 취소 요청을 모니터링할 토큰입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다. + 스트림이 삭제된 경우 + + + 스트림의 길이(바이트)를 가져옵니다. + 스트림의 길이(바이트)입니다. + 스트림이 닫혀 있는 경우 + 2 + + + 스트림 내의 현재 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + 위치가 음수 값이나 보다 큰 값으로 설정된 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. + 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. + 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트를 읽습니다. + + 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림 내의 위치를 지정된 값으로 설정합니다. + 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. + 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. + 검색 참조 지점 역할을 하는 형식의 값입니다. + 스트림의 시작 전에 검색하려고 한 경우 + + 가 보다 큰 경우 + 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림의 길이를 지정된 값으로 설정합니다. + 길이를 설정할 값입니다. + 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 + + 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. + 2 + + + + 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. + 새 바이트 배열입니다. + 2 + + + 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. + 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. + 이 스트림을 만든 바이트 배열 세그먼트입니다. + + + 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. + 데이터를 쓸 버퍼입니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 위치에서 현재 스트림에 바이트를 씁니다. + 쓸 바이트입니다. + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 + 현재 스트림이 닫혀 있는 경우 + 2 + + + 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. + 이 메모리 스트림을 쓸 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 닫혀 있는 경우 + 2 + + + 탐색에 사용할 스트림 내 위치를 지정합니다. + 2 + + + 스트림의 맨 앞을 지정합니다. + + + 스트림 내의 현재 위치를 지정합니다. + + + 스트림의 맨 끝을 지정합니다. + + + 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. + 2 + + + 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 에서 사용하는 모든 리소스를 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. + I/O 오류가 발생하는 경우 + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + 스트림이 삭제된 경우 + + + 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. + 스트림 길이(바이트)를 나타내는 long 값입니다. + Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 백업 저장소가 없는 Stream입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + I/O 오류가 발생하는 경우 + 스트림이 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. + 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. + 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에서 읽을 최대 바이트 수입니다. + + 와 의 합계가 버퍼 길이보다 큰 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. + Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. + 현재 스트림 내의 새 위치입니다. + + 매개 변수에 상대적인 바이트 오프셋입니다. + 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. + 원하는 현재 스트림의 길이(바이트)입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. + 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에 쓸 바이트 수입니다. + 총  및  버퍼 길이 보다 큽니다. + + null입니다. + + 또는  음수입니다. + 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. + 스트림이 쓰기를 지원하지 않습니다. + + 스트림이 닫힌 후 호출 되었습니다. + 1 + + + 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. + 스트림에 쓸 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 1 + + + 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + 최소 버퍼 크기입니다. + 스트림이 읽기를 지원하지 않습니다. + + 또는 가 null인 경우 + + 가 0보다 작거나 같은 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. + 최소 버퍼 크기입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + + + 내부 스트림을 반환합니다. + 내부 스트림입니다. + 2 + + + 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. + 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. + 2 + + + 내부 버퍼를 지웁니다. + 2 + + + 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. + 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. + 내부 스트림이 삭제된 경우 + 1 + + + 빈 스트림 주위의 개체입니다. + 1 + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + + 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. + 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 인덱스입니다. + 읽을 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫히는 등의 I/O 오류가 발생한 경우 + 1 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. + 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + + 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. + 1 + + + UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + + 에 쓸 수 없는 경우 + + 가 null인 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + + 또는 가 null인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + true to leave the stream open after the object is disposed; otherwise, false. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + + 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. + + 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. + 1 + + + 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. + 이 StreamWriter가 쓰고 있는 스트림입니다. + 2 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + + + 출력이 쓰여질 을 가져옵니다. + 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. + 2 + + + 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. + 현재 writer가 닫힌 경우 + I/O 오류가 발생한 경우 + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + 1 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. + 1 + + + 스트림에 문자를 씁니다. + 스트림에 쓸 문자입니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자의 하위 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자열을 씁니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작할 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 줄 종결자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열에서 읽어오는 를 구현합니다. + 2 + + + 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. + + 가 초기화되어야 하는 문자열입니다. + + 매개 변수가 null인 경우 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 버퍼의 시작 인덱스입니다. + 읽을 문자 수입니다. + + 가 null입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. + 현재 판독기가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 2 + + + 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. + 내부 문자열의 현재 위치에서 끝까지의 내용입니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 형식 지정을 제어하는 개체입니다. + + + 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + + 가 null입니다. + + + 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + 형식 지정을 제어하는 개체입니다. + + 가 null입니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 출력이 쓰여질 을 가져옵니다. + 출력이 쓰여질 Encoding입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 비동기 플러시 작업을 나타내는 작업입니다. + + + 내부 를 반환합니다. + 내부 StringBuilder입니다. + 2 + + + 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. + 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. + 2 + + + 문자를 문자열에 씁니다. + 쓸 문자입니다. + 작성기가 닫힌 경우 + 2 + + + 문자의 하위 배열을 문자열에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 또는 가 음수인 경우 + ( + )> 인 경우Length. + 작성기가 닫힌 경우 + 2 + + + 문자를 현재 문자열에 씁니다. + 쓸 문자열입니다. + 작성기가 닫힌 경우 + 2 + + + 문자를 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자를 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + TextReader에 읽을 데이터를 제공하지 않습니다. + 1 + + + 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. + I/O 오류가 발생하는 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + + 가 닫힌 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. + I/O 오류가 발생하는 경우 + + 가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 서식 지정을 제어하는 개체입니다. + + + 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. + 출력을 쓰는 문자 인코딩입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. + + + 서식 지정을 제어하는 개체를 가져옵니다. + 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. + 2 + + + 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. + 현재 TextWriter의 줄 종결자 문자열입니다. + 2 + + + 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. + 1 + + + Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + + 또는 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + 데이터 읽기를 시작하는 의 문자 위치입니다. + 쓸 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + 문자열이나 개체가 null로 전달되는 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml new file mode 100644 index 00000000..d9ad6103 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml @@ -0,0 +1,2023 @@ + + + + System.IO + + + + Считывает примитивные типы данных как двоичные значения в заданной кодировке. + 2 + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Входной поток. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. + Входной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Входной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Параметр или имеет значение null. + + + Предоставляет доступ к базовому потоку объекта . + Базовый поток, связанный с объектом BinaryReader. + 2 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. + Количество байтов, чтение которых необходимо выполнить. + Конец потока достигнут раньше, чем было выполнено чтение байтов. + Ошибка ввода-вывода. + Запрошенное значение превышает размер внутреннего буфера. + + + Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. + Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. + Ошибка ввода-вывода. + Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. + 2 + + + Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. + Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Количество байтов, чтение которых необходимо выполнить. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. + Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Число символов для чтения. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число в сжатом формате. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Поток поврежден. + + + Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. + Значение true, если байт не равен нулю; в противном случае — значение false. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. + Следующий байт, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. + Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. + Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Ошибка ввода-вывода. + Поток закрыт. + Значение отрицательно. + 2 + + + Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Символ, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Выполнено чтение символа-заместителя. + 2 + + + Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. + Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. + Количество символов, которое необходимо считать. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Поток закрыт. + Ошибка ввода-вывода. + Значение отрицательно. + 2 + + + Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. + Десятичное значение, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Число с плавающей запятой длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Целое число со знаком длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. + Байт со знаком, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Число с плавающей запятой длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. + Считываемая строка. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число без знака длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число без знака длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. + Целое число без знака длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. + 2 + + + Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Выходной поток. + Поток не поддерживает запись или был закрыт до начала операции. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. + Выходной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Выходной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Получает базовый поток . + Базовый поток, связанный с объектом BinaryWriter. + 1 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Задает без резервного хранилища. + 1 + + + Содержит базовый поток. + + + Задает позицию в текущем потоке. + Позиция в текущем потоке. + Смещение в байтах относительно . + Поле указывает точку отсчета, относительно которой указывается новая позиция. + Указатель позиции в файле перемещен в недопустимую позицию. + Значение является недопустимым. + 1 + + + Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. + Записываемое в поток значение типа Boolean (0 или 1). + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. + Записываемый в поток байт без знака. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись массива байтов в базовый поток. + Массив байтов, содержащий записываемые в поток данные. + Ошибка ввода-вывода. + Поток закрыт. + Параметр имеет значение null. + 1 + + + Выполняет запись части массива байтов в текущий поток. + Массив байтов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество записываемых байтов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. + Незаменяющий символ Юникода, который необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + + представляет собой единичный символ-заместитель. + 1 + + + Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. + Массив символов, содержащий записываемые в поток данные. + Параметр имеет значение null. + Поток закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. + Массив символов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. + Десятичное значение, которое необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число со знаком размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число со знаком размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число со знаком размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. + Байт со знаком, который необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. + Записываемое значение. + Ошибка ввода-вывода. + Параметр имеет значение null. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число без знака размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число без знака размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число без знака размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число, которое необходимо записать. + Достигнут конец потока. + Поток закрыт. + Поток закрыт. + + + Исключение, которое создается при попытке выполнить чтение за пределами потока. + 2 + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Исключение возникает, когда поток данных имеет недопустимый формат. + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. + Массив байтов без знака, из которого создается текущий поток. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Свойство имеет значение null. + Значение параметра или меньше нуля. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + Параметр или имеет отрицательное значение. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. + Исходный размер внутреннего массива в байтах. + Значение отрицательно. + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 2 + + + Возвращает или задает число байтов, выделенных для этого потока. + Длина применимой к использованию части буфера для потока. + Заданная емкость отрицательная или меньше текущей длины потока. + Текущий поток закрыт. + set вызывается для потока, емкость которого нельзя изменить. + 2 + + + Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля. + Токен для отслеживания запросов отмены. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Переопределяет метод так, что никакие действия не выполняются. + 2 + + + Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены. + Поток был ликвидирован. + + + Возвращает длину потока в байтах. + Длина потока в байтах. + Поток закрыт. + 2 + + + Возвращает или задает текущее положение в потоке. + Текущее положение в потоке. + В качестве положения задано отрицательное значение или значение, большее . + Поток закрыт. + 2 + + + Считывает блок байтов из текущего потока и записывает данные в буфер. + Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. + При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом меньше, чем . + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из текущего потока. + Байт приводится к типу или -1, если достигнут конец потока. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для положения в текущем потоке. + Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. + Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. + Значение типа , которое действует как точка ссылки поиска. + Попытка поиска выполняется до начала потока. + Значение больше значения . + + недопустим. -или-Значение вызвало арифметическое переполнение. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для длины текущего потока. + Значение задаваемой длины. + Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. + Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. + 2 + + + Записывает содержимое потока в массив байтов независимо от свойства . + Новый массив байтов. + 2 + + + Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. + Значение true, если преобразование прошло успешно; в противном случае — значение false. + Сегмент массива байтов, из которого был создан данный поток. + + + Записывает в текущий поток блок байтов, используя данные, считанные из буфера. + Буфер, из которого записываются данные. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. + Длина буфера за вычетом меньше, чем . + Параметр или имеет отрицательное значение. + Ошибка ввода-вывода. + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение текущего потока. + Записываемый байт. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. + Текущий поток закрыт. + 2 + + + Записывает все содержимое данного потока памяти в другой поток. + Поток, в который требуется осуществить запись данного потока памяти. + Свойство имеет значение null. + Текущий или конечный поток закрыт. + 2 + + + Задает позицию в потоке, используемую для поиска. + 2 + + + Задает начало потока. + + + Задает текущее положение в потоке. + + + Задает конец потока. + + + Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса . + + + При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. + Значение true, если поток поддерживает чтение; в противном случае — значение false. + 1 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. + Значение true, если поток поддерживает поиск; в противном случае — значение false. + 1 + + + Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. + Значение, которое показывает, может ли для данного потока истечь время ожидания. + 2 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 1 + + + Считывает байты из текущего потока и записывает их в другой поток. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Поток, в который будет скопировано содержимое текущего потока. + Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает все ресурсы, занятые модулем . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. + Ошибка ввода-вывода. + 2 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Поток был ликвидирован. + + + При переопределении в производном классе получает длину потока в байтах. + Длинное значение, представляющее длину потока в байтах. + Класс, созданный на основе класса Stream, не поддерживает возможность поиска. + Методы были вызваны после закрытия потока. + 1 + + + Объект Stream без резервного хранилища. + 1 + + + При переопределении в производном классе получает или задает позицию в текущем потоке. + Текущее положение в потоке. + Ошибка ввода-вывода. + Этот поток не поддерживает поиск. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. + Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. + Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. + Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. + Максимальное количество байтов, которое должно быть считано из текущего потока. + Сумма значений параметров и больше длины буфера. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 1 + + + Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. + Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + При переопределении в производном классе задает позицию в текущем потоке. + Новая позиция в текущем потоке. + Смещение в байтах относительно параметра . + Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. + Ошибка ввода-вывода. + Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе задает длину текущего потока. + Нужная длина текущего потока в байтах. + Ошибка ввода-вывода. + Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 2 + + + При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. + Массив байтов.Этот метод копирует байты из в текущий поток. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Количество байтов, которое необходимо записать в текущий поток. + Сумма  и  больше, чем длина буфера. + + — null. + + или  является отрицательным. + Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. + Поток не поддерживает запись. + + был вызван после закрытия потока. + 1 + + + Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. + Байт, записываемый в поток. + Ошибка ввода-вывода. + Поток не поддерживает запись или был закрыт до начала операции. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 1 + + + Инициализирует новый экземпляр класса для заданного потока. + Поток, который нужно считать. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. + Поток, который нужно считать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + Минимальный размер буфера. + Поток не поддерживает чтение. + Параметр или имеет значение null. + Значение параметра меньше или равно нулю. + + + Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. + Считываемый поток. + Кодировка символов, которую нужно использовать. + Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. + Минимальный размер буфера. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + + + Возвращает основной поток. + Основной поток. + 2 + + + Возвращает текущую кодировку символов, используемую текущим объектом . + Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. + 2 + + + Очищает внутренний буфер. + 2 + + + Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. + Значение true, если текущее положение находится в конце потока; в противном случае — значение false. + Основной поток удален. + 1 + + + Объект для пустого потока. + 1 + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. + Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. + Ошибка ввода-вывода. + 1 + + + Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. + Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Индекс , с которого требуется начать запись. + Максимальное число считываемых символов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Возникает ошибка ввода-вывода, например закрывается поток. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Произошла ошибка ввода-вывода. + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Следующая строка из входного потока или значение null, если достигнут конец входного потока. + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. + Количество символов в следующей строке больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца потока. + Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. + Количество символов больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. + 1 + + + Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Запись в поток запрещена. + + is null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Значение параметра или — null. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . + Значение true, чтобы заставить сбросить буфер; в противном случае — false. + 1 + + + Получает основной поток, связанный с резервным хранилищем. + Поток, в который StreamWriter выполняет запись. + 2 + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. + 2 + + + Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. + Текущее средство записи закрывается. + Произошла ошибка ввода-вывода. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + 1 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает символ в поток. + Символ, записываемый в поток. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток массив символов. + Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток дочерний массив символов. + Массив символов, содержащий записываемые данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток строку. + Строка, записываемая в поток.Если равняется null, запись не выполняется. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает символ в поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, содержащий записываемые данные. + Положение символа в буфере с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает строку в поток. + Задача, представляющая асинхронную операцию записи. + Строка, записываемая в поток.Если имеет значение null, запись не выполняется. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток признак конца строки. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Реализует класс , осуществляющий чтение из строки. + 2 + + + Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. + Строка, для которой должен быть инициализирован класс . + Значение параметра — null. + + + Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. + Текущее средство чтения закрыто. + 2 + + + Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. + Следующий символ из основной строки или значение -1, если больше нет доступных символов. + Текущее средство чтения закрыто. + 2 + + + Считывает блок символов из строки ввода и увеличивает позицию символов на . + Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Начальный индекс в буфере. + Количество символов, которые необходимо считать. + Параметр имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Следующая строка из текущей строки, или значение null, если достигнут конец строки. + Текущее средство чтения закрыто. + Недостаточно памяти для размещения буфера возвращаемых строк. + 2 + + + Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Содержимое, начиная от текущей позиции до конца основной строки. + Недостаточно памяти для размещения буфера возвращаемых строк. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. + Количество символов больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи данных в строку.Данные хранятся в основном . + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным форматом объекта. + Объект , управляющий форматированием. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . + Класс StringBuilder, в который осуществляется запись. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. + Класс StringBuilder, в который осуществляется запись. + Объект , управляющий форматированием. + Параметр имеет значение null. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Encoding, в которой осуществляется запись выходных данных. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + + + Возвращает основной . + Базовый StringBuilder. + 2 + + + Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. + Строка, содержащая символы, записанные в текущий StringWriter. + 2 + + + Записывает символ в строку. + Символ для записи. + Средство записи закрыто. + 2 + + + Записывает в строку дочерний массив символов. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Значение параметра или является отрицательным. + ( + )> .Length. + Средство записи закрыто. + 2 + + + Записывает строку в текущую строку. + Строка для записи. + Средство записи закрыто. + 2 + + + Выполняет асинхронную запись символа в строку. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в строку. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текущую строку. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в строку символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Представляет средство чтения, позволяющее считывать последовательные наборы символов. + 2 + + + Инициализирует новый экземпляр класса . + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Предоставляет TextReader без данных, доступных для чтения. + 1 + + + Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. + Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. + При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. + Следующая строка из средства чтения, или значение null, если все символы считаны. + Ошибка ввода-вывода. + Недостаточно памяти для размещения буфера возвращаемых строк. + Объект закрыт. + Количество символов в следующей строке больше . + 1 + + + Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. + Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. + Ошибка ввода-вывода. + Объект закрыт. + Недостаточно памяти для размещения буфера возвращаемых строк. + Количество символов в следующей строке больше . + 1 + + + Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. + Количество символов больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса указанным поставщиком формата. + Объект , управляющий форматированием. + + + Сохраняет символы новой строки, используемые для данного TextWriter. + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. + Кодировка символов, в которой осуществляется запись выходных данных. + 1 + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Удалено средство записи текста. + Средство записи в настоящее время используется предыдущей операцией записи. + + + Возвращает объект, управляющий форматированием. + Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. + 2 + + + Возвращает или задает признак конца строки, используемой текущим TextWriter. + Признак конца строки для текущего TextWriter. + 2 + + + Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись символа в текстовую строку или поток. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись массива символов в текстовую строку или поток. + Массив символов, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает дочерний массив символов в текстовую строку или поток. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает текстовое представление десятичного значения в текстовую строку или поток. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. + Записываемый объект. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает строку в текстовую строку или поток. + Строка для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Параметр или имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет асинхронную запись символа в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись массива символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Записывает признак конца строки в текстовую строку или поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Положение символа в , с которого начинается чтение данных. + Наибольшее количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. + Записываемый объект.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток строку, за которой следует признак конца строки. + Строка для записи.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Строка или объект передаются в виде null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает признак конца строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml new file mode 100644 index 00000000..cf7eb52f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml @@ -0,0 +1,2237 @@ + + + + System.IO + + + + 用特定的编码将基元数据类型读作二进制值。 + 2 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输入流。 + 该流不支持读取，为null 或已关闭。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输入流。 + 要使用的字符编码。 + 该流不支持读取，为null 或已关闭。 + + 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输入流。 + 要使用的字符编码。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + 该流不支持读取，为null 或已关闭。 + + 或 为 null。 + + + 公开对 的基础流的访问。 + 与 BinaryReader 关联的基础流。 + 2 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 用从流中读取的指定字节数填充内部缓冲区。 + 要读取的字节数。 + 在可以读取 之前到达了流的末尾。 + 发生 I/O 错误。 + 请求的 大于内部缓冲区大小。 + + + 返回下一个可用的字符，并且不提升字节或字符的位置。 + 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 + 发生 I/O 错误。 + 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 + 2 + + + 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 输入流中的下一个字符，如果当前无可用字符则为 -1。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 从字节数组中的指定点开始，从流中读取指定的字节数。 + 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字节数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从字符数组中的指定点开始，从流中读取指定的字符数。 + 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字符数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 以压缩格式读入 32 位整数。 + 压缩格式的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 流已损坏。 + + + 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 + 如果字节为非零，则为 true，否则为 false。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的下一个字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 + 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 发生 I/O 错误。 + 流已关闭。 + + 为负数。 + 2 + + + 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 从当前流中读取的字符。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 读取了一个代理项字符。 + 2 + + + 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 + 要读取的字符数。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 流已关闭。 + 发生 I/O 错误。 + + 为负数。 + 2 + + + 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 + 从当前流中读取的十进制数值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的一个有符号字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 4 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 + 正被读取的字符串。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 + 从该流中读取的 2 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 + 从该流中读取的 4 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 + 从该流中读取的 8 字节无符号整数。 + 已到达流的末尾。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 + 2 + + + 初始化向流中写入的 类的新实例。 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输出流。 + 该流不支持写入或者该流已关闭。 + + 为 null。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输出流。 + 要使用的字符编码。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输出流。 + 要使用的字符编码。 + 如果在释放 对象之后打开流对象，则为 true；否则为， false。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 获取 的基础流。 + 与 BinaryWriter 关联的基础流。 + 1 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 指定无后备存储区的 。 + 1 + + + 持有基础流。 + + + 设置当前流中的位置。 + 包含当前流的位置。 + 相对于 的字节偏移量。 + + 的一个字段，指示获取新位置所依据的参考点。 + 文件指针被移到无效位置。 + + 值无效。 + 1 + + + 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 + 要写入的 Boolean 值（0 或 1）。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的无符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将字节数组写入基础流。 + 包含要写入的数据的字节数组。 + 发生 I/O 错误。 + 流已关闭。 + + 为 null。 + 1 + + + 将字节数组部分写入当前流。 + 包含要写入的数据的字节数组。 + + 中开始写入的起始点。 + 要写入的字节数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 要写入的非代理项 Unicode 字符。 + 发生 I/O 错误。 + 流已关闭。 + + 是单一代理项字符。 + 1 + + + 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 为 null。 + 流已关闭。 + 发生 I/O 错误。 + 1 + + + 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 中开始写入的起始点。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个十进制值写入当前流，并将流位置提升十六个字节。 + 要写入的十进制值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的有符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 + 要写入的值。 + 发生 I/O 错误。 + + 为 null。 + 流已关闭。 + 1 + + + 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 以压缩格式写出 32 位整数。 + 要写出的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 流已关闭。 + + + 读操作试图超出流的末尾时引发的异常。 + 2 + + + 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + + + 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 在数据流的格式无效时引发的异常。 + + + 初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 用对作为此异常原因的内部异常的引用初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化为零的可扩展容量初始化 类的新实例。 + + + 基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建当前流的无符号字节数组。 + + 为 null。 + + + 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + + 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 为 null。 + + 或 小于零。 + 缓冲区长度减去 小于 。 + + + 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 使用按指定要求初始化的可扩展容量初始化 类的新实例。 + 内部数组的初始大小（以字节为单位）。 + + 为负数。 + + + 获取一个值，该值指示当前流是否支持读取。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持查找。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持写入。 + 如果流支持写入，则为 true；否则为 false。 + 2 + + + 获取或设置分配给该流的字节数。 + 流的缓冲区的可使用部分的长度。 + 容量设置为负或小于流的当前长度。 + 当前流已关闭。 + 对不能修改其容量的流调用 set。 + 2 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。 + 要监视取消请求的标记。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 重写 方法以便不执行任何操作。 + 2 + + + 异步清除此流的所有缓冲区，并监视取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。 + 流已被释放。 + + + 获取流的长度（以字节为单位）。 + 流的长度（以字节为单位）。 + 流已关闭。 + 2 + + + 获取或设置流中的当前位置。 + 流中的当前位置。 + 此位置设置为负值或大于 的值。 + 流已关闭。 + 2 + + + 从当前流中读取字节块并将数据写入缓冲区。 + 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 + 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 + + 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 的结果小于 。 + 当前流实例已关闭。 + 2 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流中读取一个字节。 + 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 + 当前流实例已关闭。 + 2 + + + 将当前流中的位置设置为指定值。 + 流内的新位置，通过将初始引用点和偏移量合并计算而得。 + 流内的新位置。它是相对于 参数的位置，而且可正可负。 + 类型 的值，它用作查找引用点。 + 试图在流的开始位置之前查找。 + + 大于 。 + + 无效。- 或 - 导致算法溢出。 + 当前流实例已关闭。 + 2 + + + 将当前流的长度设为指定值。 + 用于设置长度的值。 + 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 + + 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 + 2 + + + 将流内容写入字节数组，而与 属性无关。 + 新的字节数组。 + 2 + + + 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 + 如果转换成功，则为 true；否则为 false。 + 用于创建此流的字节数组段。 + + + 使用从缓冲区读取的数据将字节块写入当前流。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 最多写入的字节数。 + + 为 null。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 + 缓冲区长度减去 的结果小于 。 + + 或 为负。 + 发生 I/O 错误。 + 当前流实例已关闭。 + 2 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入当前位置上的当前流。 + 要写入的字节。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 + 当前流已关闭。 + 2 + + + 将此内存流的整个内容写入到另一个流中。 + 要写入此内存流的流。 + + 为 null。 + 当前流或目标流已关闭。 + 2 + + + 指定在流的位置以查找使用。 + 2 + + + 指定流的开头。 + + + 指定流内的当前位置。 + + + 指定流的结尾。 + + + 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 类的新实例。 + + + 当在派生类中重写时，获取指示当前流是否支持读取的值。 + 如果流支持读取，为 true；否则为 false。 + 1 + + + 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 + 如果流支持查找，为 true；否则为 false。 + 1 + + + 获取一个值，该值确定当前流是否可以超时。 + 一个确定当前流是否可以超时的值。 + 2 + + + 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 + 如果流支持写入，则为 true；否则为 false。 + 1 + + + 从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + 缓冲区的大小。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放由 使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 + 发生 I/O 错误。 + 2 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。默认值为 。 + 流已被释放。 + + + 当在派生类中重写时，获取流长度（以字节为单位）。 + 表示流长度（以字节为单位）的长值。 + 从 Stream 派生的类不支持查找。 + 在流关闭后调用方法。 + 1 + + + 无后备存储区的 Stream。 + 1 + + + 当在派生类中重写时，获取或设置当前流中的位置。 + 流中的当前位置。 + 发生 I/O 错误。 + 流不支持查找。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 + 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 + 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 + + 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 + 要从当前流中最多读取的字节数。 + + 与 的和大于缓冲区长度。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流不支持读取。 + 在流关闭后调用方法。 + 1 + + + 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 + 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 + 流不支持读取。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 + 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 当在派生类中重写时，设置当前流中的位置。 + 当前流中的新位置。 + 相对于 参数的字节偏移量。 + + 类型的值，指示用于获取新位置的参考点。 + 发生 I/O 错误。 + 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，设置当前流的长度。 + 所需的当前流的长度（以字节表示）。 + 发生 I/O 错误。 + 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 2 + + + 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 + 字节数组。此方法将 个字节从 复制到当前流。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 要写入当前流的字节数。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 流不支持写入。 + + 流关闭后调用。 + 1 + + + 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 + 要写入流中的字节。 + 发生 I/O 错误。 + 该流不支持写入，或者该流已关闭。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 + 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 为指定的流初始化 类的新实例。 + 要读取的流。 + + 不支持读取。 + + 为 null。 + + + 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 + 要读取的流。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 为 null。 + + + 用指定的字符编码为指定的流初始化 类的一个新实例。 + 要读取的流。 + 要使用的字符编码。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + 最小缓冲区大小。 + 流不支持读取。 + + 或 为 null。 + + 小于或等于零。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 + 要读取的流。 + 要使用的字符编码。 + 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 + 最小缓冲区大小。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + + + 返回基础流。 + 基础流。 + 2 + + + 获取当前 对象正在使用的当前字符编码。 + 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 + 2 + + + 清除内部缓冲区。 + 2 + + + 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 获取一个值，该值指示当前的流位置是否在流结尾。 + 如果当前流位置位于流的末尾，则为 true；否则为 false。 + 基础流已释放。 + 1 + + + 空流周围的 。 + 1 + + + 返回下一个可用字符，但不使用它。 + 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 + 发生 I/O 错误。 + 1 + + + 读取输入流中的下一个字符并使该字符位置提升一个字符。 + 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 + 发生 I/O 错误。 + 1 + + + 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 + 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 开始写入的 的索引。 + 要读取的最大字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 出现 I/O 错误，如流被关闭。 + 1 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生了 I/O 错误。 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取一行字符并将数据作为字符串返回。 + 输入流中的下一行；如果到达了输入流的末尾，则为 null。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 从当前流中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 + 下一行中的字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取来自流的当前位置到结尾的所有字符。 + 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 + 字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 + 1 + + + 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 + 要写入的流。 + + 不可写。 + + 为 null。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + + 或 为 null。 + + 不可写。 + + + 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + true to leave the stream open after the object is disposed; otherwise, false. + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 + 强制 刷新其缓冲区时，为 true；否则，为 false。 + 1 + + + 获取同后备存储连接的基础流。 + 此 StreamWriter 正在写入的基础流。 + 2 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + 当前编码不支持显示半个 Unicode 代理项对。 + + + 获取将输出写入到其中的 。 + 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 + 2 + + + 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 + 当前编写器已关闭。 + 出现 I/O 错误。 + 当前编码不支持显示半个 Unicode 代理项对。 + 1 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将字符写入流。 + 要写入流中的字符。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符数组写入流。 + 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符的子数组写入流。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符串写入流。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 发生 I/O 错误。 + 1 + + + 将字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将行终止符异步写入该流。 + 表示异步写操作的任务。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 实现从字符串进行读取的 。 + 2 + + + 初始化从指定字符串进行读取的 类的新实例。 + 应将 初始化为的字符串。 + + 参数为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 返回下一个可用的字符，但不使用它。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 + 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的字符块，并将字符位置提升 。 + 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 缓存区中的起始索引。 + 要读取的字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 当前读取器已关闭。 + 2 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前字符串中读取一行字符并将数据作为字符串返回。 + 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 + 当前读取器已关闭。 + 内存不足，无法为返回的字符串分配缓冲区。 + 2 + + + 从当前字符串中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 从当前位置到基础字符串的结尾之间的内容。 + 内存不足，无法为返回的字符串分配缓冲区。 + 当前读取器已关闭。 + 2 + + + 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 + 字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式控制初始化 类的新实例。 + 控制格式设置的 对象。 + + + 初始化写入指定 的 类的新实例。 + 要写入的 StringBuilder。 + + 为 null。 + + + 初始化写入指定 并具有指定格式提供程序的 类的新实例。 + 要写入的 StringBuilder。 + 控制格式设置的 对象。 + + 为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 获取将输出写入到其中的 。 + 用来写入输出的 Encoding。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + + + 返回基础 。 + 基础 StringBuilder。 + 2 + + + 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 + 包含写入到当前 StringWriter 中的字符的字符串。 + 2 + + + 将字符写入该字符串。 + 要写入的字符。 + 编写器已关闭。 + 2 + + + 将字符的子数组写入该字符串。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + 或 为负。 + ( + )> 。Length. + 编写器已关闭。 + 2 + + + 将字符串写入当前流。 + 要写入的字符串。 + 编写器已关闭。 + 2 + + + 以异步方式将字符写入流。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将字符串写入当前流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将后跟行结束符的字符写入该字符串。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将一后跟行结束符的字符串异步写入当前字符串。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 表示可读取有序字符系列的读取器。 + 2 + + + 初始化 类的新实例。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + 提供一个无数据可供读取的 TextReader。 + 1 + + + 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 + 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 + 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 2 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从文本读取器中读取一行字符并将数据作为字符串返回。 + 读取器中的下一行，或为 null （如果已读取了所有字符）。 + 发生 I/O 错误。 + 内存不足，无法为返回的字符串分配缓冲区。 + + 是关闭的。 + 下一行中的字符数大于 + 1 + + + 异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 + 发生 I/O 错误。 + + 是关闭的。 + 内存不足，无法为返回的字符串分配缓冲区。 + 下一行中的字符数大于 + 1 + + + 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 + 字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 表示可以编写一个有序字符系列的编写器。此类为抽象类。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式提供程序初始化 类的新实例。 + 控制格式设置的 对象。 + + + 存储用于此 TextWriter 的换行符。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，返回用来写输出的该字符编码。 + 用来写入输出的字符编码。 + 1 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + 文本编写器已被释放。 + 编写器正在由其前一次写操作使用。 + + + 获取控制格式设置的对象。 + 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 + 2 + + + 获取或设置由当前 TextWriter 使用的行结束符字符串。 + 当前 TextWriter 的行结束符字符串。 + 2 + + + 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符写入该文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符数组写入该文本字符串或流。 + 要写入文本流中的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符的子数组写入文本字符串或流。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符串写入到文本字符串或流。 + 要写入的字符串。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + + 或 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符写入到下一个文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符数组写入到下一个字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符串写入到下一字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将行结束符的字符串写入文本字符串或流。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符写入文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符数组写入文本字符串或流。 + 从其读取数据的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符子数组写入文本字符串或流。 + 从其读取数据的字符数组。 + 在开始读取数据时 中的字符位置。 + 要写入的最大字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符串写入文本字符串或流。 + 要写入的字符串。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + 字符串或对象作为 null 传入。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml new file mode 100644 index 00000000..26192a9d --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml @@ -0,0 +1,2246 @@ + + + + System.IO + + + + 以特定的編碼方式，將基本資料型別當做二進位值讀取。 + 2 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸入資料流。 + 資料流不支援讀取，為 null，或已經關閉。 + + + 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 + 輸入資料流。 + 要使用的字元編碼。 + 資料流不支援讀取，為 null，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + 資料流不支援讀取，為 null，或已經關閉。 + + 或 為 null。 + + + 公開 之基礎資料流的存取。 + 與 BinaryReader 相關聯的基礎資料流。 + 2 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 將從資料流讀取的指定位元組數目填入內部緩衝區。 + 要讀取的位元組數。 + 在 可讀取之前到達資料流末端。 + 發生 I/O 錯誤。 + 所要求的 大於內部緩衝區大小。 + + + 傳回下一個可用字元，而不前移位元組或字元的位置。 + 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 + 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 + 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的位元組數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 由字元陣列中的指定點開始，從資料流讀取指定字元數。 + 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的字元數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以壓縮格式讀取 32 位元整數。 + 壓縮格式的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 資料流已損毀。 + + + 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 + 如果位元組為非零值，則為 true；否則為 false。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 + 自目前資料流讀取的下一個位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 + 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 + 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為負值。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 + 自目前資料流讀取的字元。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 讀取到 Surrogate 字元 + 2 + + + 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 + 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 + 要讀取的字元數。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 已關閉資料流。 + 發生 I/O 錯誤。 + + 為負值。 + 2 + + + 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 + 自目前資料流讀取的十進位值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自目前資料流讀取的 2 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 + 自資料流讀取的帶正負號的位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 + 讀取的字串。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自這個資料流讀取 2 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自這個資料流讀取 4 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自這個資料流讀取 8 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 + 2 + + + 初始化 類別的新執行個體，其將寫入資料流。 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 資料流不支援寫入，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 要使用的字元編碼。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 輸出資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 取得 的基礎資料流。 + 與 BinaryWriter 相關聯的基礎資料流。 + 1 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 指定沒有備份存放區的 。 + 1 + + + 容納基礎資料流。 + + + 設定目前資料流位置。 + 目前資料流的位置。 + 相對於 的位元組位移。 + + 的欄位，表示要取得新位置的參考點。 + 檔案指標已移至無效的位置。 + + 值是無效的。 + 1 + + + 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 + 要寫入的 Boolean 值 (0 或 1)。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的不帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將位元組陣列寫入基礎資料流。 + 含有要寫入之資料的位元組陣列。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為 null。 + 1 + + + 將一個區域的位元組陣列寫入目前資料流。 + 含有要寫入之資料的位元組陣列。 + + 中要開始寫入的起始點。 + 要寫入的位元組數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 非 Surrogate，要寫入的 Unicode 字元。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 是單一 Surrogate 字元。 + 1 + + + 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 為 null。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 中要開始寫入的起始點。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 + 要寫入的十進位值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 要寫入的值。 + 發生 I/O 錯誤。 + + 為 null。 + 已關閉資料流。 + 1 + + + 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組不帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 以壓縮格式寫入 32 位元整數。 + 要寫入的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 已關閉資料流。 + + + 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 + 2 + + + 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + + + 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 資料流在格式無效時擲回的例外狀況。 + + + 初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 + + + 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 + 用於建立目前資料流之不帶正負號位元組的陣列。 + + 為 null。 + + + 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + + 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 為 null。 + + 或 小於零。 + 緩衝區長度減去 小於 。 + + + 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 + 內部陣列的初始大小，以位元組為單位。 + + 為負值。 + + + 取得表示目前資料流是否支援讀取的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援搜尋的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援寫入的值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 2 + + + 取得或設定配置給這個資料流的位元組數目。 + 資料流緩衝區可使用部分的長度。 + 設定的容量為負數或小於資料流目前的長度。 + 目前的資料流已經關閉。 + set 在無法修改其容量的資料流上被叫用 (Invoke)。 + 2 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 + 用來監視是否有取消要求的語彙基元。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 覆寫 方法，以便不執行任何動作。 + 2 + + + 非同步清除這個資料流的所有緩衝區，並監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。 + 已處置資料流。 + + + 取得資料流的長度，以位元組為單位。 + 資料流的長度，以位元組為單位。 + 已關閉資料流。 + 2 + + + 取得或設定資料流中目前的位置。 + 在資料流的目前位置。 + 位置設為負數值或大於 的值。 + 已關閉資料流。 + 2 + + + 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 + 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 + + 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + 緩衝區的長度減去 小於 。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從目前的資料流讀取位元組。 + 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流中的位置設定為指定的數值。 + 資料流中的新位置，是組合初始的參考點和位移計算出來的。 + 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 + + 類型的值，做為搜尋參考點。 + 在資料流開頭之前嘗試搜尋。 + + 大於 。 + 有無效的 。-或- 造成了算術溢位。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流的長度設定為指定的數值。 + 要設定長度的數值。 + 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 + + 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 + 2 + + + 不論 屬性為何，將資料流內容寫入位元組陣列。 + 新的位元組陣列。 + 2 + + + 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 + 如果轉換成功，則為 true；否則為 false。 + 從其中建立此資料流的位元組陣列區段。 + + + 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入的最大位元組數。 + + 為 null。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 + 緩衝區的長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入位元組至資料流目前位置。 + 要寫入的位元組。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 + 目前的資料流已經關閉。 + 2 + + + 將這個記憶體資料流的整個內容寫入另一個資料流。 + 要寫入這個記憶體資料流的資料流。 + + 為 null。 + 目前的資料流或目標資料流已經關閉。 + 2 + + + 指定資料流中要用於搜尋的位置。 + 2 + + + 指定資料流的開端。 + + + 指定資料流中的目前位置。 + + + 指定資料流的末端。 + + + 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 類別的新執行個體。 + + + 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 + 如果資料流支援讀取，則為 true；否則為 false。 + 1 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 + 如果資料流支援搜尋，則為 true；否則為 false。 + 1 + + + 取得值，該值判斷目前的資料流是否可以逾時。 + 值，判斷目前的資料流是否可以逾時。 + 2 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 1 + + + 從目前資料流讀取位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 所使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 發生 I/O 錯誤。 + 2 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 已處置資料流。 + + + 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + 已處置資料流。 + + + 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 + 代表資料流長度的長數值 (以位元組為單位)。 + 衍生自 Stream 的類別不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 沒有底層存放區的 Stream。 + 1 + + + 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 + 在資料流的目前位置。 + 發生 I/O 錯誤。 + 資料流不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 + 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 + 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 + + 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 + 自目前資料流讀取的最大位元組數。 + + 和 的總和大於緩衝區的長度。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 + 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + + 方法必須擲回 。 + 2 + + + 在衍生類別中覆寫時，設定在目前資料流的位置。 + 目前資料流的新位置。 + 相對於 參數的位元組位移。 + + 類型的值，表示用來取得新位置的參考點。 + 發生 I/O 錯誤。 + 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 在衍生類別中覆寫時，設定目前資料流的長度。 + 想要的目前資料流長度 (單位為位元組)。 + 發生 I/O 錯誤。 + 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 + 位元組陣列。此方法會從 複製 位元組到目前資料流。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入目前資料流的位元組數目。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 資料流不支援寫入。 + + 流关闭后调用。 + 1 + + + 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 + 寫入資料流的位元組。 + 發生 I/O 錯誤。 + 資料流不支援寫入，或資料流已經關閉。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + + 方法必須擲回 。 + 2 + + + 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 為指定的資料流，初始化 類別的新執行個體。 + 要讀取的資料流。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + 最小緩衝區大小。 + 資料流不支援讀取。 + + 或 為 null。 + + 小於或等於零值。 + + + 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要讀取的資料流。 + 要使用的字元編碼。 + true 表示在檔案開頭尋找位元順序標記；否則為 false。 + 最小緩衝區大小。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + + 傳回基礎資料流。 + 基礎資料流。 + 2 + + + 取得目前 物件使用的目前字元編碼。 + 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 + 2 + + + 清除內部緩衝區。 + 2 + + + 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得表示現行資料流位置是否在資料流結尾的值。 + 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 + 已處置基礎資料流。 + 1 + + + 空資料流周圍的 物件。 + 1 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 1 + + + 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 + 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 + 發生 I/O 錯誤。 + 1 + + + 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 + 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + 要開始寫入的 的索引。 + 要讀取的字元數上限。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤，例如資料流已經關閉。 + 1 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前資料流讀取一行字元，並將資料以字串傳回。 + 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 + 下一行中的字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到資料流末端的所有字元。 + 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 + 字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 + 1 + + + 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + + 不可寫入。 + + 為 null。 + + + 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + + 或 是 null。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 + 強制 清除其緩衝區，則為 true，否則為 false。 + 1 + + + 取得以備份存放區作介面的基礎資料流。 + StreamWriter 正在寫入的資料流。 + 2 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + + + 取得寫入輸出的 。 + + (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 + 2 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 + 目前寫入器已關閉。 + 發生 I/O 錯誤。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + 1 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + 已處置資料流。 + + + 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將一個字元寫入資料流。 + 要寫入資料流的字元。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元陣列寫入資料流。 + 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元子陣列寫入資料流。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字串寫入資料流。 + 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入資料流。 + 表示非同步寫入作業的工作。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 將行結束字元以非同步方式寫入資料流。 + 表示非同步寫入作業的工作。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 實作讀取字串的 。 + 2 + + + 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 + + 應該初始化的目的字串。 + + 參數為 null。 + + + 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 + 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 + 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + 緩衝區中的起始索引。 + 要讀取的字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負數。 + 目前的讀取器已關閉。 + 2 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前字串讀取一行字元，並將資料以字串傳回。 + 目前字串的下一行，如果已到達字串的結尾，則為 null。 + 目前的讀取器已關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 2 + + + 自目前字串非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 基礎字串從目前位置至結尾的內容。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 目前的讀取器已關閉。 + 2 + + + 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 + 字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的控制項格式，初始化 類別的新執行個體。 + 控制格式的 物件。 + + + 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 + 要寫入至其中的 StringBuilder。 + + 為 null。 + + + 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 + 要寫入至其中的 StringBuilder。 + 控制格式的 物件。 + + 為 null。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得寫入輸出的 。 + 寫入輸出的 Encoding。 + 1 + + + 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + + + 傳回基礎 。 + 基礎 StringBuilder。 + 2 + + + 傳回字串，包含被寫入至目前 StringWriter 的字元。 + 字串，包含被寫入至目前 StringWriter 的字元。 + 2 + + + 將一個字元寫入至字串。 + 要寫入的字元。 + 寫入器關閉。 + 2 + + + 將字元子陣列寫入至字串。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 或 為負數。 + ( + )> 。Length. + 寫入器關閉。 + 2 + + + 將字串寫入至目前字串。 + 要寫入的字串。 + 寫入器關閉。 + 2 + + + 以非同步方式將字元寫入至字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入至字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入至目前字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 代表可以讀取一連串連續字元的讀取器 (Reader)。 + 2 + + + 初始化 類別的新執行個體。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 提供未讀取資料的 TextReader。 + 1 + + + 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 + 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 2 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自文字讀取器讀取一行字元，並將資料以字串傳回。 + 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 + 發生 I/O 錯誤。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + + 已經關閉。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 字串，包含從目前位置到文字讀取器結尾的所有字元。 + 發生 I/O 錯誤。 + + 已經關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 + 字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的格式提供者，初始化 類別的新執行個體。 + 控制格式設定的 物件。 + + + 儲存這個 TextWriter 所使用的新行字元。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 + 寫入輸出時使用的字元編碼。 + 1 + + + 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 文字寫入器已處置。 + 寫入器目前由先前寫入作業所使用。 + + + 取得控制格式設定的物件。 + 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 + 2 + + + 取得或設定目前 TextWriter 所使用的行結束字元字串。 + 目前 TextWriter 的行結束字元字串。 + 2 + + + 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將 Boolean 值的文字表示寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列寫入到文字字串或資料流。 + 要寫入到文字資料流的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元的子陣列寫入到文字字串或資料流。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 + 要寫入的物件。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串寫入到文字字串或資料流。 + 要寫入的字串。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + + 或 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 將行結束字元寫入到文字字串或資料流。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 中開始讀取資料的字元位置。 + 要寫入的最大字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的物件。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入的字串。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + 傳入的字串或物件為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將行結束字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..4bc64f3928aedae16e08170388511348dbf676e2 GIT binary patch literal 29864 zcmeHw2V4_N*Y|7^Lhp!(pg|B2C2Z)ZAW}uDfG7$=2%$&`hEQ#QiWR#e*Z{?@h}au; z#V$7Nir7U!QL%q#HzX|Ty^rtrywC5x@Av!GyJzP=GkfODnVB=QXC_?VQS%WUA;f_D z#}9<|!jrh1N&5FB2a;8K?pHxOmi!*9{2j41+zu`OcCJLen23NtSiV(y;vX>TbL^3K_n?#Bm{_x zf@-LjGc*@l$WIhNMnYCXWCd? ztQjy9^B|&sF6n11Et$wHmf>GfV4>MwiJzZZ?eRZ9!=a}VqWqVhR7Eh&2>HY^wu=l8 zZ7nqn6h_upnr2M@-UUObyEas(J*%YBVvZ0^q!Is!SIPf60Wm{K0=#^(UHm_Kw(}Gh zAudrWr!>%>i7XomsBJIcw@*@9i8RtW{UWiXDiV3gYQnp}Efd)N%VLQ>DV6gleM#ei z3)!PdamdaqEl(PdW)_#)X#|MV#N0d8O%nCy|OcB*0TQrf; z0DYm9@fx@h~rCDG~?K!8RU|B;9GpC>$j7>ooF^hII6~%%f#8DRm1Q(%sCgM<#S|@ZB zvqa{UoYoYi2IIUV?J8!2+$lNjC}=81MYl0~O4=-}KLtI)94Y7}Hkg7i80AAyPCzhCuB(<%Y=Y0@U8i(OcAt zd9|mVK*Z?xk>o@~Kl7F5tV7>1U$mOk#3>|?nP7g>v_d398zzw&Wzh|>;gZr(C_|Gr zT*}jdu?rg^c@O&}t4kY+c8YmoA}2RrKS_CJDJGjgQ>&BDFB3}f3kS8r+ zBcw%3)AmD}1m&Z>AT_@|jX>74nD*M{L#qs+#Ziz8EncDtjA*fh_V>irJGmW+?L;!s z{oy(#L$sej%B2nsrAg2!jA%`PI3wgFS~EqOvk>{yQl;e)ZJREs5k|Caw)8!sZ95Rr zwiBdjMEgyY^1J}6h8!tRqBW;T^nwwsIUO;25wD6Z<_rporp=@vWo$MDb-@ZKD1kPg zg3@So zqHUz0GTIi2)bbio+wBs~%d;3=&~{1bq?RfrNbWdjsj`zMB2VM^Ko+EGfM zP(#N$)#$iHFJ#-EkRqaOPe|KO9_9|oUZAuQ z6D(XuYaZ>CcA9pPl6HZ1Nm2sYMpru3=!ztbY?WFG!um6>)1(Ns!P=&l(hdtdp_SNG zN}3wFA>jftZlT?zpdGY23OYc$BSnWH=UocgLAysm2WSsF+3QE`<%#W?1c~k0BT1`Z z#Q3Y1BBG7zC2fQeZB#EQ0VBrW6KNVT{+>(Ih!%S#MMR6eks_kSIuOxf9f)YLH=U%W zqN9)|zD_9rLAx+r3VJ~6PC?a}9tEi( zeF|!z^`M}aG!_N5&ObP+R?YJ#wseJN;*6y>ACpuv8Wv>h~a3OYa| zJPR1QEi0ik)BsKdaf~=jM_=HJ9KORz`UZRlum%E3L+{`%I+{Yh`)iCiUQ8d7c?c@u z-x2Q2-%^@WbQ-c5R%2g$$av=E=w6j!H4*yPAhtv{5X{eNx?bjHpg#F0; zzv|@Y7zX-%PI0^pvLX3&2UkyLZRmpxG_(-(Lq{(tts@SLOCdDbxpg{X80~L~wf!Be z3&9_TFWIsZJ$K~)HAccgtku1w48LlakP|~4(u%{s#{4^V`D@w4wWIc>f32Cn=0>e4 zQC}MRNcKr_SUhSv!t`HK#W4)B)iCsPPI0_Ur?K{PZ;{CM_v7x@w}`T+B~rum-^fGs zD@MB{;#!NxzBo+q|D7b%*8f$8KS^~YN3po9Upf3qOkYyA#bkdbC=H2YewP2Qt;DaT z{E6iMj?BN7D3)1VE>&`I43Ym|>7Od|ui-(YodnYYd^*B(a+mJc7zTJEJ8~-i#Yq2i zss23Yuab*nI%NJ;+FxV-UHNIq3+$*DcuKv%YwZPoc`xt`uK?evI#4F+22=s{A;TP! zIsjEegGuT|(qSYGB`KGr@gyBb(k!4|z<<1gsf${GGSN(umZEAI7TQRLD@iH`p6cr$ zi59vIR0lnP%}+&SOlKoaWC650@&jrJsch7jq*iDI#0(&*D@nak48#PXT%e;-DNr7| z0W<+U2bzl17;H2iX)_*zmq4H4Oebh0Npnc*%p_t;NP2{%4@nxSPsHbtl*J<7B`L#T z3P{4}O;BQnp#x;rxgANs-HcF@~=v4>$Sw2G+tdE#7F(n9xFbKMp3~R`#L3kiT z3#g9_L8*Bz$#&$V=2jkqTgOuF> zc4BDY(~|}22{oX>4zMCnqIY0uC{P;mMyf!4pmrGe*wi6B23m-QB2X8gkx*M2;zG}% zp(toG8nghhmk|w=20I@;AshpghGJoN2Saf{X=nO`t}Ikt5!tQUGm_gWC!bJ|!5|~IZg*G330JVnhtv*FyXf&V*iIgh%1c6Q7|_(A(Ddz3x(XQAbxBT zKUoA2k~k=k&y61Ll`OKdB!l7*q=+GrVrwl)X%7*R99u~wga-NwqSF%jPADiVRm4wX zd-xQEC+V?%>p{WF8p`7Pu!zcR-)`WWE@U z5XOu6KS6PdM`BuPT*oW0tH(_Xicb=!5TYWf z&}7km{0uTS6~vH)T?InEBrGnUFAyFwTw z?cgG*T7VFG7*F(T0@2#S_}Dl~lB-V;Q8GBM1@QvI7xC`S6otMR6#IFKQ2wH6g|q3gGh-Bpo$~2orWiJUaNi_#|$kqyk?4 z?C8WqAg^R-)_Bsebwm;R}&iW9@+GI_*IhsG2aV z9e8<=!yLv@dOYzG(JDVhi4B1?hbNzC7%0XiEk2QW1uB&&w&N&Rm<7r0K-{4TF(5N3 zzeJ{XK*-b{6wA~O*gTN{vWn*nw|H)BvH;qHmnw;BA8Kr|Dd7u)_`>vf9zV6+2tsKv z?*JsKNDQ!41l>d&h~|r+6(u9YLnt8Q{e@5uU#>7gT7-1yv5BrMW<_W?6-Ej{#X3R$ zQDcD}62!znKOoDqbBPzT=SRbAD7N`O#kCJp#DiWSA{9;u8VqxVAWcLLJSrv{gwzW) zL#GHL2lRVMdVF#UumM)Yqg{!Frcr!yG(Qsz0BP*Va$UJ8TprjdvQR1DNn+by4&w9D zU;D^7AiL!B!0q`m!A{SQsWpXCX`m0_y4nR3QjWhDF0vROn3gVKQCR z<1rbz?SmpFt6x{>pHl+s9mL2%i1-*}(trRC3>wTK);7e^64@)CN1WJpt9cE3>L%4~ z-;`fG|2FpZyy;))>4{T(iWc_RG2mJ8t?PG>-Yc%P)ij{ZR}>EXl(S^=iANb~^G?ZT z`1g5ksj~2;%=N= ztT#);m9N7}I+aI3&A3%5MnicA(wK~7zd&@{mWxIhsEFJOUT1UFzuMnP!=QXfVnC=-N9 z5CwuT2%RcuZ(+F4RD#MU6bRA4#U#(dXli8hE3go-22hV2`7)_Ak{h9`a77kf$_cb6euIz% zv=2LHVy((4fGC8XX>z27eWh5)BIj|uu!(bJO!Dc}JRw4@IY;Hgh%m=X^j`36iDu9qf%DBNc;uG%}wGhUD9aA1s=YE{3}J#`A=N zR6&f01p`IAhl_nkA#$x-q2eUk2O~cO+2ovBi9EL28ZDdKaP~T>=Sg_n; zk?W*XmXMzchLj)8M&PAKO4e*!wxt!v(u$44`CJnW^`geGqQLsYVd$*>tbjoOq3*81 z-hu9L_Ev_dAbkIkwE#d|T|@h;G3!*L3{INW$0T>JzFfY{n5{C9^L5H_!y8L)umfzj z?#-F&aMtK;p+dlYulI_gO@}bv`?x+y5k?=4sKZPl7DtGljF9)EF=k-XNLEu=;z=dlSe z7H%A5#i6EwL2f|}FJ3><-dpOj>G{3LU8Cn8B&3e%9~MQ-lkxo2FfinNVG=(&o-5*q zd1Ml+^sr2OTOnT*#uFrqgj}8|HB8!CVZ`Y~4$j6qqSz_XQRo%^bQl1VX?=69Lp61wzORPTKnc_5$i5K6Q@{F`B?}kAW|Rm_&j` zNuGnmY{*#g5O0rw$9;&vfS(8nQ9OM2#{#!_IMoVYp@3rGJPAVk$vilmlEUFkCGm8J z8~iPBI2A*#kS7VHfcGL9Wq~wYKzy(27GS)9AEe{m5J(e39tmgS=sp`fmTY8+ ztiS_8P&U*82Wg^E8d)MCSrl;Y56=M5uRnNg+(Fi0@Y@7JNIZP3Nf`;f5akQu$puYy z)cAL@<$>n~gZJTMn#@hqKLtu6v>gk691+xgBb55*x?)3a7Wfhq;U9~_CzV8m-U!*! zfks0;iA$_o|Mt8@D-&`{bWI>}i~UaiU^ra}r%d5p0q{$MHW5*3jD92cHjsl2dE7yJ zEGUI&XM%qQ+2$}SfDI(tt257^TkXHA&D@|o3`PwX$r_CQB>HbD9NF z`7{jUDB|)=nZ7D?nyw5i1DFbZnHU4hv!h{*5+{5h-jx!gip$e6RKh5uNl;m~E!}A!&@jUwG5;_f|(KM|6$tnOF!Zh(L6}RO-f+}xDLj9bXDfq;8vD6#}0_)D1f%O ztrX(9RsRvmlyOBuGDS^>uYW)w#{};!hCPy9<5S}JLY7;QJIg)DufHqqVQp@O+uNGE zxqH}idgF%T8tMJEM(thzJP+$d)i5T5=y`C!9pV*ed2m|)($l01N6jv5+c2hXiN87B z)iZU#UYFX-BZ}{R2(rz%KEvH;?3vA%V_wWYxk+`^+bJHq&1&jwPqmi(P#45BkJ0M3 zqcXOwWz6FIO>=u!wApBW%d5yT*w`Dg7-hc)~<>lH`+x%@ZV9q$I=> zu@>-qO2TKGY9Vb#qF<8T5_%;Yvfv|`axf}o;IuBr@WF@TLnIidqb5|(s1YIlJF3Ec%l1yw$~>s~8Q&+j&-0X-|+d;OA+!oWixhhJ@N zE~ywUTwz$aFVF0>w!%ph&CtuY@xC)$_6O3Rj;ZM#XJS$iy*}yFp5n2aowm4K?qOtn zKDgq;{M>{dTU}RoAFnoItfeid%qY45vK5y*6^(Vh_Nul4a9@K<0BWoV59l0p!nEiFpd;MW{X>M?5r)VZN!GmK??EQ zDgP1Kelle37McDR7WrQqriEVxwg(>3_nF@CxKhU5U+(dRr|rc4r!xO5~V!ic^%A$|!L$aQmehjLu%;r6OzqoME z>sy{}iH`4j&!{@6aFVfp?u2PW()G9=o4TFIj+%Y+n9ZgyBLydUii^DP-0tHaOrGGs z(=#a|Q?Fw8$EBKqP5Z9+Iy_0eKg4gK)}}&bhx4gF>0 zU1|Qk(9+&pC)y-WjoZx9u{Zs$SEg23E-_4zpsBFm4OBYCTFv~fzQj7wX?>D5rbQu0rq082kyrCseP<)4$+llG|j9yHV!s@ackVp!O8|V=h((@&8>O1 zxOtRqRE)Vpv}F{B7meFE*jslpfalbopRL`gJrb+2V_Ru!@AD~E=!u6AW%gwF<6r_y zzy#*I|CbCP^kwMDVD}<$dvhy}In2H|X#z({>=T$kKOBsp1cM25`ZE*w7raG3ja<^+ zt=kZ^;K2awJ2#v;>Qzj$Qr*W}Q?H_7Dr#5OUg>K3Y>t(E-#XV*^x0{ztQNLztdIRh zyHl?3=jtBb-Rto~f9>W;^O|RP~B2xtDFQhWc=N)p+eMp5MR3eLdnH zRzFB1%c`s?@8o^wZnAH>oK#pIDl>TF<-%3DtLUS@4t=c4me~^EX))(>R$UKPo6MI! z2|8Mzg^WFl>x-jbtB3o$dlmH2HUDyXw|r29_2P%xC-%KewRt|G>Cr3g<2t9ARRb<@ zr`GRwo4I&RKAtCY5bWJrvAt8^S{W0+;zWq^ld|v#a)G8GztDK*qPP8`v2NOQnA|ws zh;<_+QeHauam?|)ViRU0o$y$J0{BY;t}s`{$Heo%t;B-8wm8^*5@nIAG90%D&zmL3 z!HQUwS++w<0{)YB_FpZnb_hemy5Z5)`o)nfmP=83P@+@!8-nxaT3#l6FVt3h_@KXN zitZkZ63f>=?jLjUGrTTDcWg!|%sjh|<<;68x5d}Hp!`sl_qgSrvbVqWey}oa#-&ZE zZj*23-g$TEt?k;HF!#F^TOA*o#ue(WFBhhUv~*qE@Xcniu;fO1M2`&jDbwt=FQ<-{ z*&iENP`)GH;&wO1?+ZnJ>eDTP?`h$oZM6ka-_F%UcyI#tnP@gRh&q12u^EzB<@&(uuDa*y{-f8MiN^Qabg$7fsQ&9F179eY?W(yJ|dZ$)jbF12%93>joaIGsnA0GilKn zN<9?7TayNU6<0L4lPy!(k{9V5Vp8~|x8_%~M+!kpLL1iN0b*O`g?r-eC9Wld^9TL8 zEtB?lA#`mX^lZ|K1xu_JSg|2E7-b0tD`x*^R!r>lCI$>KUV!Vb_KSw0PzR^U#vT=~ z1kRO~yT-m!u}I$F_3>3iTBFYZ^P8?)6~CW*Va{1&cz!~_vK)i(EshpG`^z?jtazMq zVDHYhtX*Ehk4`TKPd@udscZbX@)a!e&x!#jLN1s;9$I@a<=F=1GJ1K)!@aY-N4#C) zvZCc()0@ZnJ*@}s4JmF8GMr|%HcxL+{bE`DxAlH)b4t%X*DPP)ccy#oJmC_vaY@T{ z+w_`)Zp5DN^&?FGLfM={COfitA#P>EE_`~iW@N~{42}O1clB zkNS9NO{{{b+_ur&qU)KbLOYFCLFK^Myib8U3aqsGJyd4hQ@bDCD!Axz?P}K-Stl4f zuYT$Gpy#YrTNJ)%nmBK5`1EMwWRC-~k)HfWXTR+(ul*XU(zEImtmTvRayUKfRf6w5 zDgE-qQ*CSXvL6B3>w?O+npqgKf%TE1Ju;<;P7?8f$(aJpt)2 z-TGF0{0HqRM*C)58oR-hV^Mtf@i@nuXi}8tm5VcK_Ue3A5f&U><5)p+9{VGH`O0_1KScf|9UvS7cPB=%c7j_{7c-#Gav>^E))YYQ;oHdeR;VZS*fguhq-@SpqK z|5w&~b!lSdgF8bOnoUSxcYAcG{_)A8VTJ))FW%GfGg5tXW&IVOtss9#e67y9=Z2)4Ie(u{TZcdIW9Hzx>41gKe@U-+y?ZQUkr;m$CEbj%h9Lu$B3%AGQ_xiuH-oO12?qt2yq(&I5H`sH8=Pn~`t05zIKAu~UqxC!U zTgqF@{f{p%^3<}nYL^ZzDc|aoI&(;alJRygZ;7~ReG-iw`EGwxi> z8s>{tvPI)YCn;%ezIb^2yuIve8f9~mqV|rUo%3U91{B@PcCH_BpkidP-Xnc1f6IZ) zx3e$59)P{6KRi!C=1jqm`sSc6_xv|6Y{W`jmq@ekRNs}&l#G|aqKHpJo7Te z@y9d;%?HO6xO1Ct?(O=@Z}#MqHhsseseW~EqN2^?93d)nwUc?^`~n@(;Uq! zLg(#mFnF?S`&r)3%wU;ogV_OF7H==l++0<%G)?!`!s(i6y(}y@$R(GIp3}R!q-p9| zgB!1U_}3J_@p||X;|pdgPCOHT=4tZF^@SHXeSWB%9358Y+r6~zv&E`G?BUu8HJWR_ zaq>)8;d!RT;OoUJE`UA93_hDnF0RY4%f6IM+K** zb|Dsnk{1~qSPb4_>=`}E<9&5`Zo$D_50wuX`_8DvJt!=cIQF=0iC&KGZ}#ulu&)Gr zS*76RYhRQ}mve;cjyi{eKb4V(A?4L-yAoXL$32z1btHGug(CfvbQ>y3HrUl?X4tU3;EQQ+I+tlcrs3w1&- zZYrp~y~iae<8aipTWh|W2kZW@ZShH�$pQO;0L%zP?$;33|s|xiPHa)JnRw5;{9V ze%93``)>{%SzuU8uVFlY3IxyOt!(n z<72Nc5V{U~H^t+KX;sY=VV}qMAKGb6Og)`cajP`X*a6R@8FjP*laoj50#WK@znlAy z&GWzCbD;FPa9pQDYC1Xt+8E8t8e`bzgi?ub5#HKTI-LIFx7i|Df`1d6y0QaJ%pNbIU8ERO3(V z3Ex)JYmB*F+wAN1(QQAn@DufGp1o??S6%SEII&^i!Q$eCpnIiDXY0TC_I|u;i=ePk zrrW$K&%l=MtxD^j9yb|2wg1cK8RmVL6!r|BdsK1k&AT5(l_r|u8xtMxUOhD2$MnUd zYnSd^4XjaZGUoU{nlP_xV&lZ?9%okhGhyS&NV#JmGB8e_;Ws?b@RL;6#Qv1wONe?3 zeTSn;s4y~r2*#%~XfWLHu#T5ukBV>x{pB7N>8_x>%V0HZxYM&IKfvj$%F6Vs2IER= z_g-S}OW5V{)l;@LUbi)mi+KE5 zhpt}#!dmmN+vL3k1IK zULIi8U>0?Am2TZ?d}#Y6I?ng2i^T%gM!90sp`II>zu(%C{jKh~J$5kHeRKckx@Pwr zrVNt3Q}<}zSBHMKtFYBgaT#Ya1x{_OA4_%B4!3N&%w4sicxtuNwu-X~p-&2Ci`^Qq z6*U=F+~dXWiQdFslf+2?M=K>$ppP6z@t>S(Ijf_gXjJb0KCdCI_hk$GW>o5b!TW1# zZP}M+X~}bNu(CCevf|m9TU*+3%(>Q4(dIFH+$x4^XUVgQ!8>_Oh9pNn36Qy(x2db0 zU9Vk98_uTDmi+bh*Kc>H1SzTH4jA-qsc)9(&JhGL$L-8ltc_AI;1)Gd1RYPuQ?*jGouU{_CulM%{Vy^s&;d?!42Vb-1th zA-T;B=O<{C?_PI^AE}~m6>9%L`;leXq|4(qWOH{;+Pg9Qj@yqIpH}kZydkNNnZC(cKa;b&TYO$VU7w_|eF6LU)QQ5J$~GsJ$Xn+R zbkCXZKU;mqm<+iCk7sS3ERc8VyCwFhXXB0y;n@SX%e;@Ab={*mB<$__zT4UA+7kLy~T>vla*`_bUXP+26#g6WbrSMko-To=gGonm5TRuo-(18M%5={s1V}qwy;BBLg z+j{OZ_sdc`@H#tuwcXfTL$;=`w0Lni(RQTn^@U$wKX_L;#!_persn%Ti{97RYu~ha zmSB(P$!3F7JWAqFQJD{a>Jl#cPn`wNo$();3&80uo(uYP%msh#HSd@eIN*G-w}j0b zvFpW_gdCiJ|M;wxNBi|?0*yGDK!c+RFy=Nle-^6gvA5PGZ^~2iwch`B_eg`)F5S%% zUW^LZw3lhG%kbJi`M6S#dv*z@H0l(a?T-~Px1Vvij%jgRuFh1>ik?1caimdV#VW5A zFXG13K3E>KL!saCid!4|Zp)UhxVbd+Y^1KtiA(!2g)rP{3?`ybjzZ%K}}$y`^$Q#HTpyr}K*eOcw}VOix~eV!>FF44?5yx6hn z%j3SI)Oz}cn3iP=A8Pd9<29zPvC(zGlw0F>jL+|W%c*is`16_mQ+3~#T7)*tA7H-C zYUIg1PTwuBR?!_RcT_C2pH#atr{8~O)b`SZ%7xqX4A*ardCl!P_K~UA%7_{Dy~D2> zcsm82*fnC15xx0J_GpXihL2OiRflO|@|tnu5)=x<#AoxD@OY)lX*g(Rmugy#KeocXT%v}F7qyPelby?-Z4vwp ze-WO$nh>7F$SuTk7vs4Lq^>zO9hQmsAW3mFOxx=3iX$fPXaO%3&ac2v+JsrWlvH+{ zC<%9#GN9qsJuF%Jl#`|rIP z*~8#0UG~*FQEac}ic8fW@fH@jES*@Jr8NI2KZ4!QsqMJ%O45|?hX*}ZI6I))bK{zK z@ppLDy==-0!}(L^Pn_)$FuYD_;e=XUZ@qT|U1kSf-u^A&v6C#j&+?~^-OI1-($84z zQ2!#j#?3J^+wh&{#C7vUQwmzo8Phz>j?Gd#uy&)2((=Z*&vEP}C1!)n5=MIQddkNq zk6O00VM^>-v2t_@*$h14un%J==Fd6V@7T_(D(Pk-WU#$R(hJTNN%xIWLeF#o~rcWrOA zON&h&T_`WS{3e_?`0;4j71N!V8O$rp%Cw$Zhq>Hc&38|AXB>Vo__T`YoBMo=*M%QS z!e8>JqHLf;jZ%X<$|E6VA48TC0?xx9RkdqxkNQ?+GftFyCveIBx;=jJb-hB@z7 zwN)qV@h+@?m6oad`lVe_mX7z28&!sJX-_LYf1UkGG3RCcfQqkpBg1Fzg9m9zyakR| zR)+ZbSLclARhp@8X^`DCSfO&zmksCFh951Rv3$h15WgYrM_g)_r;k?18ItfVYxU7X zNl9aC0#h}WvjZ-0^19r{^Saz1eF;nc>4{71Quxg$A>~W6B=;m7TvU+wq`EOU;P=M< z@BLdA(ywEA2B#N;Rb%bb|NUB{(JGgE-R@%Cu=sfK?wTs!fGFnFi#JtwTiE>veO>tM z3)B2h4c)r(TF&0xZP!|QOrEf9>Ef)Gy@Ib;bCHE_?3){$%?AaZHIHs-W!U>{sEh4Y znq=wgd?iM)@LgKc<&&4XV=tQA<@fKi2voVZal^fdKG-;YUAm=g^}O3 zRz;W(ontwi&GsAbT^V~Ju{fyyoeY)C<4uWh3S-+5+PWSuy$ z(rbO1-HGXzZT*|pgnDRQzq@?uw16eI!yGG;O43mGlG87&U$L70v&@BFr6JB4Av0y%87Q@>W@`+Q(kv@&u*pKkTf6LaVkH& z0;j1)&GURmV-BBSV{TBZqX{#N4K8(Au^sGeN8z$iKn@LSEy>-tHh1?weyr8S#oZN- zwYm;Aw{&xH|HEUgC3z~B!A&y`&gF$lmgMreX5^Bb_R|dVKW9mfx1VOQ!#S25D_a}l zXr3js4*{(Sh)?*Bd^{NAM&geL{f>`^&WE3g4+b1M->(aD>RI89`pO40)Mxc)z5c3M z`2O?c_{9mLV72Sz3Mg;dm&OTk-u)s@9)H3;mcGX+rtj$HE6zW2<%P;C@xIWp4Y?MTmj z%c(s?+}H&Xxxtl}7WphZdSYGp6|QEo=_%b$`8fw3aKCySHPJVU)e!0$%&PE?o*58T z8U8J!r(^Sov@M5bx%fH{yP~>+=@dKpeasR1QnyJ>m%YCwKPf(2x#4ZLnF6QzwjXoB z?iq46&olM5zbLve@R^0%{`IYQqYtgcj>^NI(~vj_mfs}qoySd|GTp&f4(5S{vqVtyysvmf zSFR~F5LCTdcm6%+@Fki0jo&|yNa}`H9XlCQGxovzXU&<1PH$M%`|+oPjS0acF1rD2QR-H*7Zl&r!ie^mKlY3i<(^2&Qw%SJ~jER-NaFY^xhU_ z4P6k3D(qFezPHHA<=@)4E1}`^#Sdq*k-!^wGwL<)QX{>5>AcWB2X}vCJW5$@In?Ca z@Cu9XyPwRpIuI36d}oC7iUUwThj<<5WLDKORYsv8V_@w{UzHV{rsd9y-`D+iY(%r^znX-3R&hlRNtX;jIM8E#nT0Myu z+FLc7?Jy#}Y}_X1EY+FX`?>4Y&lT6HcoyfJynJE(<)(>KnjZ}qC;uQ^w5*pL_xARH z9)d$HkI;i>9ND#t`hVnmWTVled=6Y-cI2K{nowH zupT*Iy3aHVcGxlc_8H~jMcLC+2gp5LX8y9^p%q)B&-)`5!6pVD&usC#ZMwH|?EBcwFww=>{pc9a{C+Kdz0hyD@LancmjU zuG~BGEP1yybw|w_quPI~Ap7RK#Mzg=-T%~fHrrHa9Q!iorlYRB|3}9g)vHdtst?d= z(w<--mu{uv-n+y?^Zg0cc&6F1uB{EHgHo`J>B9`B_q&&{@kHWcTa?se>#&M-*`tMX z)$imR#VTT5Cr9-d*#-Riod2%bu?9l&LXJtq)Km5#P!H`QsGiiFKXM0`pZLHwSTvJbb zyZze2A3^Su7)PJ2tTGD^b-2-E%F|)GJeMI+6TPk)%~DLXOl#0qpeMaGN+0=H-Pa^Hyh?=HJHlIIQ&BQMc3f>U0(3w%OYwoU2C=WoI1URQ)6Y@XJye{_uKuPo)_IM zGU_pUQKMV#Z55Z36}d|{7ag3hB%^EdZm(xfjo$z#kE(@X(K~gr4tlA2oO)5({rLy` zixrjMhUM@Q<_y`E?3A7Arc`?VV8MYtuXTcwuGF9B@go8szYC4$+Srht695SL@za!1tq!1@Z9RPxd-vwegBcA z_fJ2%`1RL)e!)THulsE5JZ#NfIqtZ*jg7S{r!U?|ykzgydCATS5~K-ve3ma4{t%du zwzC%l)As`T>@x3smgA0>^j#>EkM1}w6~dy4R_30v_Nu=-PI zX8;~}2*aP?py_4M;Jh|`H$qrvs5nCy<1mrImhw7{13T8zb2;S4Yl#95|34AK5qoh zgHJE0WE!()_r3VmYti(;N5%v8@7NYTd&7+*tJ7Wk?Jin&<4Im)ps4Oc>#Ed!sr4o{ z9uFpL8|!>le|^aF%Hc0s9%dXJ#aO6ZzIyJcS@S248lXN?Ye4X}^a%CgtK0|n-=H_> z%j)>d*blACPuutpRkWz zoZMPG_Y$6a9?z|0X#H;Z!Z}hrH)rjn|B1?iLuk)5divz0*a@bX%jYL}mbwd-Zgb1oC?vecV?9K-J# zfBtF`pzw_u&M(Ydo#pequ-o8O4@=i~-R`qwYtXE*yd_SbMlauXDx7`s&goIyy9W%N zH##1OFIbRPu=(t{Tj^ob*1D)w?wWpmTKtAu|HSEPszVp$M{0kFsH|!!D}Ej6*!_h@ zU2Dx3w;;d6E-hS7?c(TURm}3%mW;i(UA!h~o<7``ErSIe8nnIskou}_joSj&T|BwE z)bNF~XZ@t8D|4B&KBwaQmd!eKaq5u%kpo&a(t`4`9i}X-d!h7ZCA0MMHM7(iq5h2< Wp1$q6S?`&3-GH>3>Qxc2ZvH + + + System.IO + + + + Reads primitive data types as binary values in a specific encoding. + 2 + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The input stream. + The stream does not support reading, is null, or is already closed. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The input stream. + The character encoding to use. + The stream does not support reading, is null, or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The input stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support reading, is null, or is already closed. + + or is null. + + + Exposes access to the underlying stream of the . + The underlying stream associated with the BinaryReader. + 2 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Fills the internal buffer with the specified number of bytes read from the stream. + The number of bytes to be read. + The end of the stream is reached before could be read. + An I/O error occurs. + Requested is larger than the internal buffer size. + + + Returns the next available character and does not advance the byte or character position. + The next available character, or -1 if no more characters are available or the stream does not support seeking. + An I/O error occurs. + The current character cannot be decoded into the internal character buffer by using the selected for the stream. + 2 + + + Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + The next character from the input stream, or -1 if no characters are currently available. + An I/O error occurs. + The stream is closed. + 2 + + + Reads the specified number of bytes from the stream, starting from a specified point in the byte array. + The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of bytes to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of characters from the stream, starting from a specified point in the character array. + The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of characters to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads in a 32-bit integer in compressed format. + A 32-bit integer in compressed format. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + The stream is corrupted. + + + Reads a Boolean value from the current stream and advances the current position of the stream by one byte. + true if the byte is nonzero; otherwise, false. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the next byte from the current stream and advances the current position of the stream by one byte. + The next byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. + A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. + The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + An I/O error occurs. + The stream is closed. + + is negative. + 2 + + + Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + A character read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + A surrogate character was read. + 2 + + + Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. + A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. + The number of characters to read. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + The stream is closed. + An I/O error occurs. + + is negative. + 2 + + + Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. + A decimal value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. + An 8-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. + A 2-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. + A 4-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. + An 8-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a signed byte from this stream and advances the current position of the stream by one byte. + A signed byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. + A 4-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. + The string being read. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. + A 2-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. + A 4-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. + An 8-byte unsigned integer read from this stream. + The end of the stream is reached. + An I/O error occurs. + The stream is closed. + 2 + + + Writes primitive types in binary to a stream and supports writing strings in a specific encoding. + 2 + + + Initializes a new instance of the class that writes to a stream. + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The output stream. + The stream does not support writing or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The output stream. + The character encoding to use. + The stream does not support writing or is already closed. + + or is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The output stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support writing or is already closed. + + or is null. + + + Gets the underlying stream of the . + The underlying stream associated with the BinaryWriter. + 1 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Specifies a with no backing store. + 1 + + + Holds the underlying stream. + + + Sets the position within the current stream. + The position with the current stream. + A byte offset relative to . + A field of indicating the reference point from which the new position is to be obtained. + The file pointer was moved to an invalid location. + The value is invalid. + 1 + + + Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. + The Boolean value to write (0 or 1). + An I/O error occurs. + The stream is closed. + 1 + + + Writes an unsigned byte to the current stream and advances the stream position by one byte. + The unsigned byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a byte array to the underlying stream. + A byte array containing the data to write. + An I/O error occurs. + The stream is closed. + + is null. + 1 + + + Writes a region of a byte array to the current stream. + A byte array containing the data to write. + The starting point in at which to begin writing. + The number of bytes to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + The non-surrogate, Unicode character to write. + An I/O error occurs. + The stream is closed. + + is a single surrogate character. + 1 + + + Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + A character array containing the data to write. + + is null. + The stream is closed. + An I/O error occurs. + 1 + + + Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. + A character array containing the data to write. + The starting point in from which to begin writing. + The number of characters to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a decimal value to the current stream and advances the stream position by sixteen bytes. + The decimal value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. + The eight-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. + The two-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. + The four-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. + The eight-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a signed byte to the current stream and advances the stream position by one byte. + The signed byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. + The four-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. + The value to write. + An I/O error occurs. + + is null. + The stream is closed. + 1 + + + Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. + The two-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. + The four-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. + The eight-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a 32-bit integer in a compressed format. + The 32-bit integer to be written. + The end of the stream is reached. + The stream is closed. + The stream is closed. + + + The exception that is thrown when reading is attempted past the end of a stream. + 2 + + + Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. + + + Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + The exception that is thrown when a data stream is in an invalid format. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class with an expandable capacity initialized to zero. + + + Initializes a new non-resizable instance of the class based on the specified byte array. + The array of unsigned bytes from which to create the current stream. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. + The array of unsigned bytes from which to create this stream. + The setting of the property, which determines whether the stream supports writing. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + + is null. + + or is less than zero. + The buffer length minus is less than . + + + Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. + The array of unsigned bytes from which to create this stream. + The index in at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + + is null. + + or are negative. + The buffer length minus is less than . + + + Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. + + is null. + + or is negative. + The buffer length minus is less than . + + + Initializes a new instance of the class with an expandable capacity initialized as specified. + The initial size of the internal array in bytes. + + is negative. + + + Gets a value indicating whether the current stream supports reading. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports seeking. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 2 + + + Gets or sets the number of bytes allocated for this stream. + The length of the usable portion of the buffer for the stream. + A capacity is set that is negative or less than the current length of the stream. + The current stream is closed. + set is invoked on a stream whose capacity cannot be modified. + 2 + + + Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. + The token to monitor for cancellation requests. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Overrides the method so that no action is performed. + 2 + + + Asynchronously clears all buffers for this stream, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. + The stream has been disposed. + + + Gets the length of the stream in bytes. + The length of the stream in bytes. + The stream is closed. + 2 + + + Gets or sets the current position within the stream. + The current position within the stream. + The position is set to a negative value or a value greater than . + The stream is closed. + 2 + + + Reads a block of bytes from the current stream and writes the data to a buffer. + The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. + When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. + The zero-based byte offset in at which to begin storing data from the current stream. + The maximum number of bytes to read. + + is null. + + or is negative. + + subtracted from the buffer length is less than . + The current stream instance is closed. + 2 + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the current stream. + The byte cast to a , or -1 if the end of the stream has been reached. + The current stream instance is closed. + 2 + + + Sets the position within the current stream to the specified value. + The new position within the stream, calculated by combining the initial reference point and the offset. + The new position within the stream. This is relative to the parameter, and can be positive or negative. + A value of type , which acts as the seek reference point. + Seeking is attempted before the beginning of the stream. + + is greater than . + There is an invalid . -or- caused an arithmetic overflow. + The current stream instance is closed. + 2 + + + Sets the length of the current stream to the specified value. + The value at which to set the length. + The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. + + is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. + 2 + + + Writes the stream contents to a byte array, regardless of the property. + A new byte array. + 2 + + + Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. + true if the conversion was successful; otherwise, false. + The byte array segment from which this stream was created. + + + Writes a block of bytes to the current stream using data read from a buffer. + The buffer to write data from. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + + is null. + The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. + + subtracted from the buffer length is less than . + + or are negative. + An I/O error occurs. + The current stream instance is closed. + 2 + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current stream at the current position. + The byte to write. + The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. + The current stream is closed. + 2 + + + Writes the entire contents of this memory stream to another stream. + The stream to write this memory stream to. + + is null. + The current or target stream is closed. + 2 + + + Specifies the position in a stream to use for seeking. + 2 + + + Specifies the beginning of a stream. + + + Specifies the current position within a stream. + + + Specifies the end of a stream. + + + Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class. + + + When overridden in a derived class, gets a value indicating whether the current stream supports reading. + true if the stream supports reading; otherwise, false. + 1 + + + When overridden in a derived class, gets a value indicating whether the current stream supports seeking. + true if the stream supports seeking; otherwise, false. + 1 + + + Gets a value that determines whether the current stream can time out. + A value that determines whether the current stream can time out. + 2 + + + When overridden in a derived class, gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 1 + + + Reads the bytes from the current stream and writes them to another stream. + The stream to which the contents of the current stream will be copied. + + is null. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + The stream to which the contents of the current stream will be copied. + The size of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Asynchronously reads the bytes from the current stream and writes them to another stream. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + + is null. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + The token to monitor for cancellation requests. The default value is . + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases all resources used by the . + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. + An I/O error occurs. + 2 + + + Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. The default value is . + The stream has been disposed. + + + When overridden in a derived class, gets the length in bytes of the stream. + A long value representing the length of the stream in bytes. + A class derived from Stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + A Stream with no backing store. + 1 + + + When overridden in a derived class, gets or sets the position within the current stream. + The current position within the stream. + An I/O error occurs. + The stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. + An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. + The zero-based byte offset in at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The sum of and is larger than the buffer length. + + is null. + + or is negative. + An I/O error occurs. + The stream does not support reading. + Methods were called after the stream was closed. + 1 + + + Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. + The unsigned byte cast to an Int32, or -1 if at the end of the stream. + The stream does not support reading. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. + A value, in miliseconds, that determines how long the stream will attempt to read before timing out. + The method always throws an . + 2 + + + When overridden in a derived class, sets the position within the current stream. + The new position within the current stream. + A byte offset relative to the parameter. + A value of type indicating the reference point used to obtain the new position. + An I/O error occurs. + The stream does not support seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, sets the length of the current stream. + The desired length of the current stream in bytes. + An I/O error occurs. + The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 2 + + + When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + An array of bytes. This method copies bytes from to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + The sum of  and  is greater than the buffer length. + + is null. + + or  is negative. + An I/O error occured, such as the specified file cannot be found. + The stream does not support writing. + + was called after the stream was closed. + 1 + + + Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current position in the stream and advances the position within the stream by one byte. + The byte to write to the stream. + An I/O error occurs. + The stream does not support writing, or the stream is already closed. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. + A value, in miliseconds, that determines how long the stream will attempt to write before timing out. + The method always throws an . + 2 + + + Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream. + The stream to be read. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. + The stream to be read. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding. + The stream to be read. + The character encoding to use. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + The minimum buffer size. + The stream does not support reading. + + or is null. + + is less than or equal to zero. + + + Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. + The stream to read. + The character encoding to use. + true to look for byte order marks at the beginning of the file; otherwise, false. + The minimum buffer size. + true to leave the stream open after the object is disposed; otherwise, false. + + + Returns the underlying stream. + The underlying stream. + 2 + + + Gets the current character encoding that the current object is using. + The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. + 2 + + + Clears the internal buffer. + 2 + + + Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets a value that indicates whether the current stream position is at the end of the stream. + true if the current stream position is at the end of the stream; otherwise false. + The underlying stream has been disposed. + 1 + + + A object around an empty stream. + 1 + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. + An I/O error occurs. + 1 + + + Reads the next character from the input stream and advances the character position by one character. + The next character from the input stream represented as an object, or -1 if no more characters are available. + An I/O error occurs. + 1 + + + Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. + The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The index of at which to begin writing. + The maximum number of characters to read. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs, such as the stream is closed. + 1 + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurred. + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current stream and returns the data as a string. + The next line from the input stream, or null if the end of the input stream is reached. + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads a line of characters asynchronously from the current stream and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the stream. + The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. + The number of characters is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. + The stream to write to. + + is not writable. + + is null. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. + The stream to write to. + The character encoding to use. + + or is null. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + + or is null. + + is negative. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + true to leave the stream open after the object is disposed; otherwise, false. + + or is null. + + is negative. + + is not writable. + + + Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . + true to force to flush its buffer; otherwise, false. + 1 + + + Gets the underlying stream that interfaces with a backing store. + The stream this StreamWriter is writing to. + 2 + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + The current encoding does not support displaying half of a Unicode surrogate pair. + + + Gets the in which the output is written. + The specified in the constructor for the current instance, or if an encoding was not specified. + 2 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. + The current writer is closed. + An I/O error has occurred. + The current encoding does not support displaying half of a Unicode surrogate pair. + 1 + + + Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Provides a StreamWriter with no backing store that can be written to, but not read from. + 1 + + + Writes a character to the stream. + The character to write to the stream. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a character array to the stream. + A character array containing the data to write. If is null, nothing is written. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a subarray of characters to the stream. + A character array that contains the data to write. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The buffer length minus is less than . + + or is negative. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a string to the stream. + The string to write to the stream. If is null, nothing is written. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + An I/O error occurs. + 1 + + + Writes a character to the stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the stream asynchronously. + A task that represents the asynchronous write operation. + A character array that contains the data to write. + The character position in the buffer at which to begin reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string to the stream asynchronously. + A task that represents the asynchronous write operation. + The string to write to the stream. If is null, nothing is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Implements a that reads from a string. + 2 + + + Initializes a new instance of the class that reads from the specified string. + The string to which the should be initialized. + The parameter is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. + The current reader is closed. + 2 + + + Reads the next character from the input string and advances the character position by one character. + The next character from the underlying string, or -1 if no more characters are available. + The current reader is closed. + 2 + + + Reads a block of characters from the input string and advances the character position by . + The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The starting index in the buffer. + The number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The current reader is closed. + 2 + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current string and returns the data as a string. + The next line from the current string, or null if the end of the string is reached. + The current reader is closed. + There is insufficient memory to allocate a buffer for the returned string. + 2 + + + Reads a line of characters asynchronously from the current string and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the string and returns them as a single string. + The content from the current position to the end of the underlying string. + There is insufficient memory to allocate a buffer for the returned string. + The current reader is closed. + 2 + + + Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. + The number of characters is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing information to a string. The information is stored in an underlying . + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format control. + An object that controls formatting. + + + Initializes a new instance of the class that writes to the specified . + The StringBuilder to write to. + + is null. + + + Initializes a new instance of the class that writes to the specified and has the specified format provider. + The StringBuilder to write to. + An object that controls formatting. + + is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the in which the output is written. + The Encoding in which the output is written. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + + + Returns the underlying . + The underlying StringBuilder. + 2 + + + Returns a string containing the characters written to the current StringWriter so far. + The string containing the characters written to the current StringWriter. + 2 + + + Writes a character to the string. + The character to write. + The writer is closed. + 2 + + + Writes a subarray of characters to the string. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + + or is negative. + ( + )> . Length. + The writer is closed. + 2 + + + Writes a string to the current string. + The string to write. + The writer is closed. + 2 + + + Writes a character to the string asynchronously. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the string asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string to the current string asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the current string. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Represents a reader that can read a sequential series of characters. + 2 + + + Initializes a new instance of the class. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Provides a TextReader with no data to read from. + 1 + + + Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. + An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. + The is closed. + An I/O error occurs. + 1 + + + Reads the next character from the text reader and advances the character position by one character. + The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 2 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the text reader and returns the data as a string. + The next line from the reader, or null if all characters have been read. + An I/O error occurs. + There is insufficient memory to allocate a buffer for the returned string. + The is closed. + The number of characters in the next line is larger than + 1 + + + Reads a line of characters asynchronously and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. + The number of characters in the next line is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the text reader and returns them as one string. + A string that contains all characters from the current position to the end of the text reader. + An I/O error occurs. + The is closed. + There is insufficient memory to allocate a buffer for the returned string. + The number of characters in the next line is larger than + 1 + + + Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. + The number of characters is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Represents a writer that can write a sequential series of characters. This class is abstract. + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format provider. + An object that controls formatting. + + + Stores the newline characters used for this TextWriter. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, returns the character encoding in which the output is written. + The character encoding in which the output is written. + 1 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The text writer is disposed. + The writer is currently in use by a previous write operation. + + + Gets an object that controls formatting. + An object for a specific culture, or the formatting of the current culture if no other culture is specified. + 2 + + + Gets or sets the line terminator string used by the current TextWriter. + The line terminator string for the current TextWriter. + 2 + + + Provides a TextWriter with no backing store that can be written to, but not read from. + 1 + + + Writes the text representation of a Boolean value to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a character array to the text string or stream. + The character array to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters to the text string or stream. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte floating-point value to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object to the text string or stream by calling the ToString method on that object. + The object to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string to the text string or stream. + The string to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + + or is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character array to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If is null, nothing is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a line terminator to the text string or stream. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character followed by a line terminator to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes an array of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The character position in at which to start reading data. + The maximum number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value followed by a line terminator to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. + The object to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string followed by a line terminator to the text string or stream. + The string to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + A string or object is passed in as null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes an array of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If the character array is null, only the line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml new file mode 100644 index 00000000..07b2661f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. + 2 + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. + Der Eingabestream. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + oder ist null. + + + Gewährt Zugriff auf den zugrunde liegenden Stream von . + Der BinaryReader zugeordnete, zugrunde liegende Stream. + 2 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. + Die Anzahl der zu lesenden Bytes. + Das Ende des Streams ist erreicht, bevor gelesen werden konnte. + E/A-Fehler. + Die angeforderten überschreiten die interne Puffergröße. + + + Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. + Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. + 2 + + + Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. + Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Bytes. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 32-Bit-Ganzzahl in komprimiertem Format. + Eine 32-Bit-Ganzzahl in komprimiertem Format. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Der Datenstrom ist beschädigt. + + + Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + true, wenn das Byte ungleich 0 (null) ist, andernfalls false. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + Das nächste aus dem aktuellen Stream gelesene Byte. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. + Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + E/A-Fehler. + Der Stream ist geschlossen. + + ist negativ. + 2 + + + Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein aus dem aktuellen Stream gelesenes Zeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Ein Ersatzzeichenzeichen wurde gelesen. + 2 + + + Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Zeichen. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + Der Stream ist geschlossen. + E/A-Fehler. + + ist negativ. + 2 + + + Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. + Ein aus dem aktuellen Stream gelesener Dezimalwert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. + Die gelesene Zeichenfolge. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. + Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. + Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. + 2 + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. + + + Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. + Der Ausgabestream. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Ruft den zugrunde liegenden Stream von ab. + Der BinaryWriter zugeordnete, zugrunde liegende Stream. + 1 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Gibt eine -Klasse ohne Sicherungsspeicher an. + 1 + + + Enthält den zugrunde liegenden Stream. + + + Legt die Position im aktuellen Stream fest. + Die Position im aktuellen Stream. + Ein Byteoffset im Verhältnis zu . + Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. + Der Dateizeiger wurde an eine ungültige Position verschoben. + Der -Wert ist ungültig. + 1 + + + Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. + Der zu schreibende Boolean-Wert (0 (null) oder 1). + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Bytearray in den zugrunde liegenden Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + E/A-Fehler. + Der Stream ist geschlossen. + + ist null. + 1 + + + Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Bytes. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). + E/A-Fehler. + Der Stream ist geschlossen. + + ist ein einzelnes Ersatzzeichen. + 1 + + + Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + + ist null. + Der Stream ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. + Der zu schreibende Dezimalwert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Der zu schreibende 8-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Der zu schreibende 4-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. + Der zu schreibende Wert. + E/A-Fehler. + + ist null. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. + Die zu schreibende 32-Bit-Ganzzahl. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + Der Stream ist geschlossen. + + + Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. + 2 + + + Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. + + + Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. + + ist null. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + + Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + + ist null. + + oder ist kleiner als 0. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , bei dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. + Die Anfangsgröße des internen Arrays in Bytes. + + ist negativ. + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 2 + + + Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. + Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. + Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. + Der aktuelle Stream ist geschlossen. + set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. + 2 + + + Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. + Das Token zum überwachen von Abbruchanforderungen . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen . + Der Stream wurde freigegeben. + + + Ruft die Länge des Streams in Bytes ab. + Die Länge des Streams in Bytes. + Der Stream ist geschlossen. + 2 + + + Ruft die aktuelle Position im Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. + Der Stream ist geschlossen. + 2 + + + Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. + Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. + Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + + subtrahiert von der Pufferlänge ist kleiner als . + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem aktuellen Stream. + Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Position im aktuellen Stream auf den angegebenen Wert fest. + Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. + Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. + Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. + Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. + + ist größer als . + Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. + Der Wert, auf den die Länge festgelegt werden soll. + Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. + + ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. + 2 + + + Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. + Ein neues Bytearray. + 2 + + + Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. + true, wenn die Konvertierung erfolgreich war, andernfalls false. + Das Bytearraysegment, aus dem der Stream erstellt wurde. + + + Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. + + subtrahiert von der Pufferlänge ist kleiner als . + + oder ist negativ. + E/A-Fehler. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuelle Position im aktuellen Stream. + Das zu schreibende Byte. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. + Der aktuelle Stream ist geschlossen. + 2 + + + Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. + Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. + + ist null. + Der aktuelle Stream oder der Zielstream ist geschlossen. + 2 + + + Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. + 2 + + + Gibt den Anfang eines Streams an. + + + Gibt die aktuelle Position innerhalb eines Streams an. + + + Gibt das Ende eines Streams an. + + + Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. + 1 + + + Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + 2 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 1 + + + Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt alle vom verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + E/A-Fehler. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + Der Stream wurde freigegeben. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. + Ein Long-Wert, der die Länge des Streams in Bytes darstellt. + Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Ein Stream ohne Sicherungsspeicher. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. + Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. + Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. + Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. + Die Summe aus und ist größer als die Pufferlänge. + + ist null. + + oder ist negativ. + E/A-Fehler. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. + Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. + Die neue Position innerhalb des aktuellen Streams. + Ein Byteoffset relativ zum -Parameter. + Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. + Die gewünschte Länge des aktuellen Streams in Bytes. + E/A-Fehler. + Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. + Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. + Die Summe der  und  ist größer als die Länge des Puffers. + + ist null. + + oder  ist negativ. + E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. + Der Stream unterstützt das Schreiben nicht. + + wurde aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das Byte, das in den Stream geschrieben werden soll. + E/A-Fehler. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Der zu lesende Stream. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + Die Mindestgröße des Puffers. + Lesevorgänge werden vom Stream nicht unterstützt. + + oder ist null. + + ist kleiner oder gleich 0 (null). + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. + Die Mindestgröße des Puffers. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + + Gibt den zugrunde liegenden Stream zurück. + Der zugrunde liegende Stream. + 2 + + + Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. + Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. + 2 + + + Löscht den internen Puffer. + 2 + + + Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. + true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. + Der zugrunde liegende Stream wurde verworfen. + 1 + + + Ein -Objekt um einen leeren Stream. + 1 + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. + E/A-Fehler. + 1 + + + Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. + Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Index von , bei dem mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + Ein E/A-Fehler ist aufgetreten. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. + Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. + Die Anzahl der Zeichen ist niedriger als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + + ist schreibgeschützt. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + + oder ist null. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. + true, um zum Entleeren des Puffers zu zwingen, andernfalls false. + 1 + + + Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. + Der Stream, in den dieser StreamWriter schreibt. + 2 + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. + 2 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. + Der aktuelle Writer wird geschlossen. + Ein E/A-Fehler ist aufgetreten. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + 1 + + + Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt ein Zeichen in den Stream. + Das in den Stream zu schreibende Zeichen. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Zeichenarray in den Stream. + Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Teilarray von Zeichen in den Stream. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt eine Zeichenfolge in den Stream. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Implementiert einen , der aus einer Zeichenfolge liest. + 2 + + + Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. + Die Zeichenfolge, mit der der initialisiert werden soll. + Der -Parameter ist null. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Anfangsindex im Puffer. + Die Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. + Der aktuelle Reader ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + 2 + + + Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. + Die Anzahl der Zeichen ist niedriger als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. + Ein -Objekt zum Steuern der Formatierung. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . + Der StringBuilder, in den geschrieben werden soll. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. + Der StringBuilder, in den geschrieben werden soll. + Ein -Objekt zum Steuern der Formatierung. + + ist null. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die Encoding, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + + + Gibt den zugrunde liegenden zurück. + Der zugrunde liegende StringBuilder. + 2 + + + Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + 2 + + + Schreibt ein Zeichen in die Zeichenfolge. + Das zu schreibende Zeichen. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Teilarray von Zeichen in die Zeichenfolge. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + + oder ist negativ. + ( + )> .Length. + Der Writer ist geschlossen. + 2 + + + Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. + Die zu schreibende Zeichenfolge. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Stellt einen TextReader ohne zu lesende Daten bereit. + 1 + + + Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. + Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 2 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. + E/A-Fehler. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der ist geschlossen. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. + E/A-Fehler. + Der ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. + Die Anzahl der Zeichen ist niedriger als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. + Ein -Objekt zum Steuern der Formatierung. + + + Speichert die für diesen TextWriter verwendeten Zeilenendemarken. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. + Die Zeichencodierung, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Textwriter wird freigegeben. + Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Ruft ein Objekt zum Steuern der Formatierung ab. + Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. + 2 + + + Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. + Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. + 2 + + + Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichenarray. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. + Das zu schreibende Objekt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + + oder ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + Eine Zeichenfolge oder ein Objekt wird als null übergeben. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml new file mode 100644 index 00000000..0b2c206b --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml @@ -0,0 +1,2090 @@ + + + + System.IO + + + + Lee tipos de datos primitivos como valores binarios en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. + La secuencia de entrada. + La secuencia no admite la lectura, es null, o ya está cerrada. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de o es null. + + + Expone el acceso a la secuencia subyacente de . + Secuencia subyacente asociada a BinaryReader. + 2 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. + Número de bytes que se va a leer. + Se llega al final de la secuencia antes de se ha podido leer. + Se produce un error de E/S. + Solicitado es mayor que el tamaño del búfer interno. + + + Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. + Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. + 2 + + + Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. + Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. + Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de bytes que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. + Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de caracteres que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero de 32 bits en formato comprimido. + Entero de 32 bits en formato comprimido. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + La secuencia está dañada. + + + Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Es true si el byte es distinto de cero; en caso contrario, es false. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Siguiente byte que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. + Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. + Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + Se produce un error de E/S. + La secuencia está cerrada. + + es negativo. + 2 + + + Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. + Carácter que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + Se ha leído un carácter suplente. + 2 + + + Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. + Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. + Número de caracteres que se va a leer. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + La secuencia está cerrada. + Se produce un error de E/S. + + es negativo. + 2 + + + Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. + Valor decimal que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. + Valor de punto flotante de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. + Entero con signo de 2 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Entero con signo de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. + Entero con signo de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. + Byte con signo que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Valor de punto flotante de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. + Cadena que se lee. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. + Entero sin signo de 2 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. + Entero sin signo de 4 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. + Entero sin signo de 8 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase que escribe en una secuencia. + + + Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. + Flujo de salida. + La secuencia no admite escritura o ya se encuentra cerrada. + + es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + Flujo de salida. + Codificación de caracteres que se utilizará. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. + Flujo de salida. + Codificación de caracteres que se utilizará. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Obtiene la secuencia subyacente del objeto . + Flujo subyacente asociado a BinaryWriter. + 1 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Especifica un objeto sin memoria auxiliar. + 1 + + + Contiene la secuencia subyacente. + + + Establece la posición en la secuencia actual. + Posición con la secuencia actual. + Desplazamiento de bytes relacionado con . + Un campo de que indica el punto de referencia del que se obtiene la nueva posición. + El puntero de archivo se ha movido a una posición no válida. + El valor de no es válido. + 1 + + + Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. + Valor Boolean que se va a escribir (0 ó 1). + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte sin signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una matriz de bytes en la secuencia subyacente. + Matriz de bytes que contiene los datos que se van a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es null. + 1 + + + Escribe una región de una matriz de bytes en la secuencia actual. + Matriz de bytes que contiene los datos que se van a escribir. + Punto inicial de donde comenzará la escritura. + Número de bytes que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. + El carácter Unicode no suplente que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es un carácter suplente único. + 1 + + + Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + + es null. + La secuencia está cerrada. + Se produce un error de E/S. + 1 + + + Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Punto inicial de donde se empieza a leer. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. + Valor decimal que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Valor de punto flotante de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero con signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero con signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero con signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte con signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Valor de punto flotante de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. + Valor que se va a escribir. + Se produce un error de E/S. + + es null. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero sin signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero sin signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero sin signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero de 32 bits en formato comprimido. + Entero de 32 bits que se va a escribir. + Se llega al final de la secuencia. + La secuencia está cerrada. + La secuencia está cerrada. + + + Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. + 2 + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Excepción que se inicia cuando el formato de un flujo de datos no es válido. + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. + + + Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. + Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + El valor de es null. + + o es menor que cero. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + o son negativos. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. + El valor de es null. + + o es negativo. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. + Tamaño inicial de la matriz interna en bytes. + + es negativo. + + + Obtiene un valor que indica si la secuencia actual admite lectura. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite búsquedas. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 2 + + + Obtiene o establece el número de bytes asignados a esta secuencia. + Longitud de la parte utilizable del búfer para la secuencia. + Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. + La secuencia actual está cerrada. + set se invoca en una secuencia cuya capacidad no se puede modificar. + 2 + + + Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero. + Token para supervisar solicitudes de cancelación. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Reemplaza el método de modo que no se realice ninguna acción. + 2 + + + De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación. + Se ha eliminado la secuencia. + + + Obtiene la longitud de la secuencia en bytes. + Longitud de la secuencia en bytes. + La secuencia está cerrada. + 2 + + + Obtiene o establece la posición actual dentro de la secuencia. + Posición actual dentro de la secuencia. + La posición se establece en un valor negativo o un valor mayor que . + La secuencia está cerrada. + 2 + + + Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. + Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. + Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. + Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + + resta de la longitud del búfer es menor que . + La instancia de la secuencia actual está cerrada. + 2 + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia actual. + El byte convertido en un o -1 si se llega al final de la secuencia. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la posición dentro de la secuencia actual en el valor especificado. + Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. + Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. + Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. + Se ha intentado realizar una búsqueda antes del inicio de la secuencia. + + es mayor que . + Hay un no válido . o bien se produjo un desbordamiento aritmético. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la longitud de la secuencia actual en el valor especificado. + Valor en el que establecer la longitud. + La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. + + es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. + 2 + + + Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . + Nueva matriz de bytes. + 2 + + + Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. + Es true si la conversión se realiza correctamente; en caso contrario, es false. + El segmento de matriz de bytes desde el que se creó esta secuencia. + + + Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número máximo de bytes que se pueden escribir. + El valor de es null. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. + + resta de la longitud del búfer es menor que . + + o son negativos. + Se produce un error de E/S. + La instancia de la secuencia actual está cerrada. + 2 + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte en la posición actual de la secuencia actual. + Byte que se va a escribir. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. + La secuencia actual está cerrada. + 2 + + + Escribe el contenido completo de esta secuencia de memoria en otra secuencia. + Secuencia en la que se va a escribir esta secuencia de memoria. + El valor de es null. + La secuencia actual o de destino está cerrada. + 2 + + + Especifica la posición usada para buscar en una secuencia. + 2 + + + Especifica el comienzo de una secuencia. + + + Especifica lo posición actual dentro de la secuencia. + + + Especifica el final de una secuencia. + + + Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase . + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. + true si la secuencia admite lectura; en caso contrario, false. + 1 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. + true si la secuencia admite búsquedas; en caso contrario, false. + 1 + + + Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + 2 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 1 + + + Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera todos los recursos usados por . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Se produce un error de E/S. + 2 + + + Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + Se ha eliminado la secuencia. + + + Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. + Un valor Long que representa la longitud de la secuencia en bytes. + Una clase derivada de Stream no admite la búsqueda. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Stream sin memoria auxiliar. + 1 + + + Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. + Posición actual dentro de la secuencia. + Se produce un error de E/S. + La secuencia no admite búsquedas. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. + Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. + Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. + Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. + Número máximo de bytes que se deben leer de la secuencia actual. + La suma de y es mayor que la longitud del búfer. + El valor de es null. + + o es negativo. + Se produce un error de E/S. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. + Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. + La nueva posición dentro de la secuencia actual. + Desplazamiento de bytes relacionado con el parámetro . + Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. + Se produce un error de E/S. + La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. + Longitud deseada de la secuencia actual, en bytes. + Se produce un error de E/S. + La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. + Matriz de bytes.Este método copia bytes desde al flujo actual. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número de bytes que se deben escribir en la secuencia actual. + La suma de  y  es mayor que la longitud del búfer. + + es null. + + o  es negativo. + Se produjo un error de E/S, como no se puede encontrar el archivo especificado. + La secuencia no es compatible con la escritura. + + se llama después de cerrar la secuencia. + 1 + + + Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. + Byte que se debe escribir en la secuencia. + Se produce un error de E/S. + La secuencia no admite escritura o ya se encuentra cerrada. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 1 + + + Inicializa una nueva instancia de la clase para el flujo especificado. + Secuencia que se va a leer. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + Tamaño mínimo de búfer. + La secuencia no admite lectura. + El valor de o es null. + + es menor o igual que cero. + + + Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. + Tamaño mínimo de búfer. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + + + Devuelve la secuencia subyacente. + Secuencia subyacente. + 2 + + + Obtiene la codificación de caracteres que actualmente utiliza este objeto . + Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . + 2 + + + Borra el búfer interno. + 2 + + + Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene un valor que indica si la actual posición está al final de la secuencia. + Es true si la actual posición está al final de la secuencia; en caso contrario, es false. + Se ha eliminado la secuencia subyacente. + 1 + + + Objeto en torno a una secuencia vacía. + 1 + + + Devuelve el siguiente carácter disponible pero no lo consume. + Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. + El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. + Se produce un error de E/S. + 1 + + + Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. + Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Índice de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + La longitud del búfer menos es menor que . + El valor de es null. + + o es negativo. + Se produce un error de E/S, como el cierre de la secuencia. + 1 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + + o es negativo. + El se cierra. + Error de E/S. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. + El número de caracteres en la siguiente línea es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la secuencia. + Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. + El número de caracteres es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. + 1 + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + No se puede escribir en . + + is null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + + o es null. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . + Es true para que vacíe su búfer; en caso contrario, es false. + 1 + + + Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. + Secuencia en la que escribe este StreamWriter. + 2 + + + Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. + truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + + + Obtiene el donde se escribe el resultado. + + especificado en el constructor para la instancia actual o si no se ha especificado una codificación. + 2 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. + El sistema de escritura actual está cerrado. + Se produjo un error de E/S. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + 1 + + + Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe un carácter en la secuencia. + Carácter que se va a escribir en la secuencia. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una matriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una submatriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una cadena en la secuencia. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comienza la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Implementa que lee en una cadena. + 2 + + + Inicializa una nueva instancia de la clase que lee en la cadena especificada. + Cadena en la que debe inicializarse. + El parámetro es null. + + + Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Devuelve el siguiente carácter disponible pero no lo consume. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + El sistema de lectura actual está cerrado. + 2 + + + Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. + Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. + El sistema de lectura actual está cerrado. + 2 + + + Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . + Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Índice inicial del búfer. + Número de caracteres que se va a leer. + + es null. + La longitud del búfer menos es menor que . + + o son negativos. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. + El sistema de lectura actual está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + 2 + + + Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Contenido desde la posición actual hasta el final de la cadena subyacente. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. + El número de caracteres es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir información en una cadena.La información se almacena en el subyacente. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Inicializa una nueva instancia de la clase que escribe en el especificado. + Objeto StringBuilder en el que se va a escribir. + + es null. + + + Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. + Objeto StringBuilder en el que se va a escribir. + Objeto que controla las operaciones de formato. + + es null. + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene el donde se escribe el resultado. + Encoding donde se escribe el resultado. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + + + Devuelve el subyacente. + Objeto StringBuilder subyacente. + 2 + + + Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. + Cadena que contiene los caracteres escritos en el StringWriter actual. + 2 + + + Escribe un carácter en la cadena. + Carácter que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe una submatriz de caracteres en la cadena. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + + o son negativos. + ( + ) > .Length. + El sistema de escritura está cerrado. + 2 + + + Escribe una cadena en la cadena actual. + Cadena que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe un carácter en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena actual de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Representa un lector que puede leer una serie secuencial de caracteres. + 2 + + + Inicializa una nueva instancia de la clase . + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. + + + Proporciona un TextReader sin datos del que leer. + 1 + + + Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. + Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. + Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 2 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. + Línea siguiente del lector o null si se han leído todos los caracteres. + Se produce un error de E/S. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El objeto está cerrado. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. + Se produce un error de E/S. + El objeto está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. + El número de caracteres es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Almacena los caracteres de nueva línea usados para el TextWriter. + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. + Codificación de caracteres donde se escriben los resultados. + 1 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se desecha el sistema de escritura de texto. + El sistema de escritura está actualmente en uso por una operación de escritura anterior. + + + Obtiene un objeto que controla las operaciones de formato. + Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. + 2 + + + Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. + Cadena de terminador de línea para el TextWriter actual. + 2 + + + Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. + Objeto que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena en la cadena o secuencia de texto. + Cadena que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + El valor de o es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea en la cadena o secuencia. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + Posición del carácter en donde comenzar a leer datos. + Número máximo de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. + Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. + Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + Una cadena u objeto se pasa como null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml new file mode 100644 index 00000000..30dc29ab --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml @@ -0,0 +1,2201 @@ + + + + System.IO + + + + Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux d'entrée. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + + Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. + Flux d'entrée. + Encodage des caractères à utiliser. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux d'entrée. + Encodage des caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + ou a la valeur null. + + + Expose l'accès au flux sous-jacent de l'élément . + Flux sous-jacent associé à l'élément BinaryReader. + 2 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. + Nombre d'octets à lire. + La fin du flux est atteinte avant que n'ait pu être lu. + Une erreur d'E/S se produit. + + demandé est plus grand que la taille de la mémoire tampon interne. + + + Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. + Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. + 2 + + + Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. + Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre d'octets à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. + Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier 32 bits au format compressé. + Entier 32 bits au format compressé. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Le flux est endommagé. + + + Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. + true si l'octet est différent de zéro ; sinon, false. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. + Octet suivant lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. + Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. + Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Une erreur d'E/S se produit. + Le flux est fermé. + + est négatif. + 2 + + + Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. + Caractère lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Un caractère de substitution a été lu. + 2 + + + Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. + Nombre de caractères à lire. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Le flux est fermé. + Une erreur d'E/S se produit. + + est négatif. + 2 + + + Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. + Valeur décimale lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Valeur à virgule flottante de 8 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. + Entier signé de 2 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Entier signé de 4 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Entier signé de 8 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. + Octet signé lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Valeur à virgule flottante de 4 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. + Chaîne en cours de lecture. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. + Entier non signé de 2 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. + Entier non signé de 4 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. + Entier non signé de 8 octets lu dans ce flux. + La fin du flux est atteinte. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe qui écrit dans un flux. + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux de sortie. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. + Flux de sortie. + Encodage de caractères à utiliser. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux de sortie. + Encodage de caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Obtient le flux sous-jacent de . + Flux sous-jacent associé à BinaryWriter. + 1 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + 1 + + + Spécifie sans magasin de sauvegarde. + 1 + + + Contient le flux sous-jacent. + + + Définit la position dans le flux actuel. + Position dans le flux actuel. + Offset d'octet par rapport à . + Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. + Le pointeur de fichier a été déplacé vers un emplacement non valide. + La valeur n'est pas valide. + 1 + + + Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. + Valeur Boolean à écrire (0 ou 1). + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. + Octet non signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un tableau d'octets dans le flux sous-jacent. + Tableau d'octets contenant les données à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + a la valeur null. + 1 + + + Écrit une zone d'un tableau d'octets dans le flux actuel. + Tableau d'octets contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre d'octets à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Caractère Unicode de non-substitution à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + est un caractère de substitution unique. + 1 + + + Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Tableau de caractères contenant les données à écrire. + + a la valeur null. + Le flux est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. + Tableau de caractères contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. + Valeur décimale à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Valeur à virgule flottante de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. + Octet signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Valeur à virgule flottante de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. + Valeur à écrire. + Une erreur d'E/S se produit. + + a la valeur null. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier non signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier non signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier non signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un nombre entier 32 bits dans un format compressé. + Entier 32 bits à écrire. + La fin du flux est atteinte. + Le flux est fermé. + Le flux est fermé. + + + Exception levée en cas de tentative de lecture au-delà de la fin du flux. + 2 + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Exception qui est levée lorsque le format d'un flux de données n'est pas valide. + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. + Tableau d'octets non signés à partir duquel créer le flux actuel. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + + a la valeur null. + + ou est inférieur à zéro. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. + Taille initiale du tableau interne, en octets. + + est négatif. + + + Obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 2 + + + Obtient ou définit le nombre d'octets alloués pour ce flux. + Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. + La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. + Le flux actuel est fermé. + set est appelé sur un flux dont la capacité ne peut pas être modifiée. + 2 + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. + Jeton pour surveiller les demandes d'annulation. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplace la méthode afin qu'aucune action ne soit effectuée. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation. + Le flux a été supprimé. + + + Obtient la longueur du flux en octets. + Longueur du flux en octets. + Le flux est fermé. + 2 + + + Obtient ou définit la position actuelle dans le flux. + Position actuelle dans le flux. + La position correspond à une valeur négative ou à une valeur supérieure à . + Le flux est fermé. + 2 + + + Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. + Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. + Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + + soustrait à la longueur de la mémoire tampon est inférieur à . + L'instance du flux actuel est fermée. + 2 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet dans le flux actuel. + Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. + L'instance du flux actuel est fermée. + 2 + + + Définit la position dans le flux actuel à la valeur spécifiée. + Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. + Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. + Valeur de type , qui sert de point de référence à la recherche. + Tentative de recherche avant le début du flux. + + est supérieur à . + Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. + L'instance du flux actuel est fermée. + 2 + + + Définit la longueur du flux actuel à la valeur spécifiée. + Valeur à laquelle définir la longueur. + Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. + + est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. + 2 + + + Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . + Nouveau tableau d'octets. + 2 + + + Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. + true si la conversion a réussi ; sinon, false. + Segment de tableau d'octets à partir duquel ce flux a été créé. + + + Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre maximal d'octets à écrire. + + a la valeur null. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. + + soustrait à la longueur de la mémoire tampon est inférieur à . + + ou est négatif. + Une erreur d'E/S se produit. + L'instance du flux actuel est fermée. + 2 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux actuel. + Octet à écrire. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. + Le flux actuel est fermé. + 2 + + + Écrit le contenu complet de ce flux de mémoire dans un autre flux. + Flux dans lequel écrire ce flux de mémoire. + + a la valeur null. + Le flux en cours ou le flux cible est fermé. + 2 + + + Spécifie la position au sein d'un flux à utiliser pour la recherche. + 2 + + + Spécifie le début d'un flux. + + + Spécifie la position actuelle au sein d'un flux. + + + Spécifie la fin d'un flux. + + + Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe . + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux prend en charge la lecture ; sinon, false. + 1 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux prend en charge la recherche ; sinon, false. + 1 + + + Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + 2 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 1 + + + Lit les octets du flux actuel et les écrit dans un autre flux. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Flux vers lequel le contenu du flux actuel sera copié. + Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. + Une erreur d'E/S se produit. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + Le flux a été supprimé. + + + En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. + Valeur de type long représentant la longueur du flux en octets. + Une classe dérivée de Stream ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Élément Stream sans magasin de stockage. + 1 + + + En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. + Position actuelle dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. + Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. + Nombre maximal d'octets à lire dans le flux actuel. + La somme de et de est supérieure à la longueur de la mémoire tampon. + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. + Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. + Nouvelle position dans le flux actuel. + Offset d'octet par rapport au paramètre . + Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. + Longueur souhaitée du flux actuel en octets. + Une erreur d'E/S se produit. + Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. + Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre d'octets à écrire dans le flux actuel. + La somme des  et  est supérieure à la longueur du tampon. + + est null. + + ou  est un nombre négatif. + Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. + Le flux ne prend pas en charge l'écriture. + + a été appelée une fois que le flux a été fermé. + 1 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. + Octet à écrire dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié. + Flux à lire. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. + Flux à lire. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. + Flux à lire. + Encodage des caractères à utiliser. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + Taille minimale de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + + ou a la valeur null. + + est inférieur ou égal à zéro. + + + Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à lire. + Encodage des caractères à utiliser. + true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. + Taille minimale de la mémoire tampon. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + + Retourne le flux sous-jacent. + Flux sous-jacent. + 2 + + + Obtient l'encodage de caractères actuel utilisé par l'objet actuel. + Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . + 2 + + + Efface la mémoire tampon interne. + 2 + + + Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. + true si la position actuelle dans le flux est à la fin du flux ; sinon, false. + Le flux sous-jacent a été supprimé. + 1 + + + Objet autour d'un flux vide. + 1 + + + Retourne le caractère disponible suivant, mais ne le consomme pas. + Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. + Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. + Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Index de auquel commencer l'écriture. + Nombre maximal de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S, telle que la fermeture du flux, se produit. + 1 + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S s'est produite. + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. + Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du flux. + Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. + Le nombre de caractères est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. + Le flux dans lequel écrire. + + n'est pas accessible en écriture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + + ou est null. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . + true pour forcer à vider sa mémoire tampon ; sinon, false. + 1 + + + Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. + Flux dans lequel ce StreamWriter écrit. + 2 + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + + + Obtient le dans lequel la sortie est écrite. + + spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. + 2 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. + Le writer actuel est fermé. + Une erreur d'E/S s'est produite. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + 1 + + + Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. + 1 + + + Écrit un caractère dans le flux. + Caractère à écrire dans le flux. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un sous-tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit une chaîne dans le flux. + Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire où commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire dans le flux.Si est null, rien n'est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un terminateur de ligne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Implémente qui lit une chaîne. + 2 + + + Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. + Chaîne à laquelle doit être initialisé. + Le paramètre est null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Retourne le prochain caractère disponible, mais ne le consomme pas. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Le lecteur actuel est fermé. + 2 + + + Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. + Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. + Le lecteur actuel est fermé. + 2 + + + Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . + Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Index de début dans la mémoire tampon. + Nombre de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Le lecteur actuel est fermé. + 2 + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. + Le lecteur actuel est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + 2 + + + Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. + Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le lecteur actuel est fermé. + 2 + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. + Le nombre de caractères est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. + Objet qui contrôle la mise en forme. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié. + StringBuilder dans lequel écrire. + + a la valeur null. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. + StringBuilder dans lequel écrire. + Objet qui contrôle la mise en forme. + + a la valeur null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le dans lequel la sortie est écrite. + Encoding dans lequel la sortie est écrite. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + + + Retourne le sous-jacent. + StringBuilder sous-jacent. + 2 + + + Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. + Chaîne contenant les caractères écrits dans le StringWriter en cours. + 2 + + + Écrit un caractère dans la chaîne. + Caractère à écrire. + Le writer est fermé. + 2 + + + Écrit un sous-tableau de caractères dans la chaîne. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + ou est négatif. + ( + )> .Length. + Le writer est fermé. + 2 + + + Écrit une chaîne dans la chaîne actuelle. + Chaîne à écrire. + Le writer est fermé. + 2 + + + Écrit un caractère dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans la chaîne actuelle de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Représente un lecteur capable de lire une série séquentielle de caractères. + 2 + + + Initialise une nouvelle instance de la classe . + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Fournit un TextReader sans données à lire. + 1 + + + Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. + Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. + Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. + La ligne suivante du lecteur ou null si tous les caractères ont été lus. + Une erreur d'E/S se produit. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + + est fermé. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. + Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. + Une erreur d'E/S se produit. + + est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. + Le nombre de caractères est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. + Objet qui contrôle la mise en forme. + + + Stocke les caractères de saut de ligne utilisés pour ce TextWriter. + + + Libère toutes les ressources utilisées par l'objet . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. + Encodage de caractères dans lequel la sortie est écrite. + 1 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le writer de texte est supprimé. + Le writer est actuellement utilisé par une opération d'écriture précédente. + + + Obtient un objet qui contrôle la mise en forme. + Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. + 2 + + + Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. + Chaîne de marque de fin de ligne pour le TextWriter actuel. + 2 + + + Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. + Objet à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne dans la chaîne ou le flux de texte. + Chaîne à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + + ou a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + Dans , position de caractère à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + Une chaîne ou un objet est passé en tant que null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml new file mode 100644 index 00000000..46070bec --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml @@ -0,0 +1,2123 @@ + + + + System.IO + + + + Legge i tipi di dati primitivi come valori binari in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. + Flusso di input. + Il flusso non supporta la lettura, è null o è già chiuso. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. + Flusso di input. + Codifica dei caratteri da usare. + Il flusso non supporta la lettura, è null o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. + Flusso di input. + Codifica dei caratteri da usare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la lettura, è null o è già chiuso. + + o è null. + + + Espone l'accesso al flusso sottostante dell'oggetto . + Flusso sottostante associato all'oggetto BinaryReader. + 2 + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Inserisce nel buffer interno il numero specificato di byte letti dal flusso. + Numero di byte da leggere. + È stata raggiunta la fine del flusso prima che fosse possibile leggere . + Si è verificato un errore di I/O. + I richiesti sono superiori alla dimensione del buffer interno. + + + Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. + Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. + 2 + + + Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. + Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. + Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di byte da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. + Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di caratteri da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero a 32 bit in formato compresso. + Intero a 32 bit in formato compresso. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + Flusso danneggiato. + + + Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + true se il byte è diverso da zero; in caso contrario, false. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + Byte successivo letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. + Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. + Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è negativo. + 2 + + + Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Carattere letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + È stato letto un carattere surrogato. + 2 + + + Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. + Numero di caratteri da leggere. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Il flusso è chiuso. + Si è verificato un errore di I/O. + + è negativo. + 2 + + + Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. + Valore decimale letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. + Valore a virgola mobile a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. + Intero con segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Intero con segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. + Intero con segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. + Byte con segno letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Valore a virgola mobile a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. + Stringa da leggere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. + Intero senza segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero senza segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero senza segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe che scrive in un flusso. + + + Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. + Flusso di output. + Il flusso non supporta la scrittura o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. + Flusso di output. + Codifica dei caratteri da utilizzare. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso di output. + Codifica dei caratteri da utilizzare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Ottiene il flusso sottostante dell'oggetto . + Flusso sottostante associato a BinaryWriter. + 1 + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Specifica un oggetto privo di archivio di backup. + 1 + + + Contiene il flusso principale. + + + Imposta la posizione all'interno del flusso corrente. + Posizione all'interno del flusso corrente. + Offset dei byte relativo a . + Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. + Il puntatore a file è stato spostato in un percorso non valido. + Il valore di non è valido. + 1 + + + Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. + Valore Boolean da scrivere (0 o 1). + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una matrice di byte nel flusso sottostante. + Matrice di caratteri che contiene i dati da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è null. + 1 + + + Scrive un'area di una matrice di byte nel flusso corrente. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale nel parametro da cui iniziare la scrittura. + Numero di byte da scrivere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Carattere Unicode non surrogato da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è un carattere surrogato singolo. + 1 + + + Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + + è null. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 1 + + + Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale in dal quale avviare la scrittura. + Numero di caratteri da inserire. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. + Valore decimale da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Valore a virgola mobile a otto byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Valore a virgola mobile a quattro byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. + Valore da scrivere. + Si è verificato un errore di I/O. + + è null. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Inserisce un valore intero a 32 bit in un formato compresso. + Intero da 32 bit da scrivere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Il flusso è chiuso. + + + Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. + 2 + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Eccezione generata se un flusso di dati è in un formato non valido. + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. + Matrice di byte senza segno da cui creare il flusso corrente. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + + è null. + + o è minore di zero. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + o è un valore negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. + + è null. + Il valore di o è negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. + Dimensione iniziale in byte della matrice interna. + + è negativo. + + + Ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 2 + + + Ottiene o imposta il numero di byte allocati per questo flusso. + Lunghezza della parte usabile del buffer per il flusso. + È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. + Il flusso corrente è chiuso. + set è stato richiamato su un flusso del quale non è possibile modificare la capacità. + 2 + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. + Token da monitorare per le richieste di annullamento. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. + 2 + + + Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento. + Il flusso è stato eliminato. + + + Ottiene la lunghezza in byte del flusso. + Lunghezza del flusso in byte. + Il flusso è chiuso. + 2 + + + Ottiene o imposta la posizione corrente all'interno del flusso. + Posizione corrente all'interno del flusso. + La posizione è impostata su un valore negativo o maggiore di . + Il flusso è chiuso. + 2 + + + Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. + Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. + Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. + Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + + sottratto alla lunghezza del buffer è minore di . + L'istanza del flusso corrente è chiusa. + 2 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso corrente. + Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la posizione all'interno del flusso corrente sul valore specificato. + Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. + Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. + Valore di tipo , che funge da punto di riferimento per la ricerca. + La ricerca viene tentata prima dell'inizio del flusso. + + è maggiore di . + Il valore di non è valido. -oppure- causato da un overflow aritmetico. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la lunghezza del flusso corrente sul valore specificato. + Valore su cui impostare la lunghezza. + Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. + + è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. + 2 + + + Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . + Nuova matrice di byte. + 2 + + + Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. + true se la conversione riesce; in caso contrario, false. + Segmento di matrice di byte da cui è stato creato questo flusso. + + + Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero massimo di byte da scrivere. + + è null. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. + + sottratto alla lunghezza del buffer è minore di . + + o è un valore negativo. + Si è verificato un errore di I/O. + L'istanza del flusso corrente è chiusa. + 2 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente all'interno del flusso corrente. + Byte da scrivere. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. + Il flusso corrente è chiuso. + 2 + + + Scrive l'intero contenuto del flusso di memoria in un altro flusso. + Flusso in cui scrivere il flusso di memoria. + + è null. + Il flusso corrente o di destinazione è chiuso. + 2 + + + Specifica la posizione in un flusso da utilizzare per le ricerche. + 2 + + + Specifica l'inizio di un flusso. + + + Specifica la posizione corrente all'interno di un flusso. + + + Specifica la fine di un flusso. + + + Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso supporta la lettura; in caso contrario, false. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso supporta la ricerca; in caso contrario, false. + 1 + + + Ottiene un valore che determina se il flusso corrente prevede il timeout. + Valore che determina se il flusso corrente prevede il timeout. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 1 + + + Legge i byte dal flusso corrente e li scrive in un altro flusso. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Si è verificato un errore di I/O. + 2 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + Il flusso è stato eliminato. + + + Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. + Valore long che rappresenta la lunghezza del flusso in byte. + Una classe derivata da Stream non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Oggetto Stream privo di archivio di backup. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. + Posizione corrente all'interno del flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. + Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. + Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. + Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. + Numero massimo di byte da leggere dal flusso corrente. + La somma di e è maggiore della lunghezza del buffer. + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. + Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. + Nuova posizione all'interno del flusso corrente. + Offset dei byte rispetto al parametro . + Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. + Lunghezza desiderata del flusso corrente in byte. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. + Matrice di byte.Questo metodo copia i byte da nel flusso corrente. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero di byte da scrivere nel flusso corrente. + La somma di  e  è maggiore della lunghezza del buffer. + + è null. + + o  è negativo. + Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. + Il flusso non supporta la scrittura. + + è stato chiamato dopo la chiusura del flusso. + 1 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. + Byte da scrivere nel flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura o è già chiuso. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato. + Flusso da leggere. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. + Flusso da leggere. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. + Flusso da leggere. + Codifica dei caratteri da usare. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + Dimensione minima del buffer. + Il flusso non supporta la lettura. + + o è null. + + è minore o uguale a zero. + + + Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. + Flusso da leggere. + Codifica dei caratteri da usare. + true per cercare i byte order mark all'inizio del file; in caso contrario, false. + Dimensione minima del buffer. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + + Restituisce il flusso sottostante. + Flusso sottostante. + 2 + + + Ottiene la codifica caratteri corrente usata dall'oggetto corrente. + Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . + 2 + + + Cancella il buffer interno. + 2 + + + Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. + true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. + Il flusso sottostante è stato eliminato. + 1 + + + Oggetto che include un flusso vuoto. + 1 + + + Restituisce il carattere successivo disponibile senza usarlo. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. + Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Indice di da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O, come la chiusura del flusso. + 1 + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. + Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. + Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. + Il numero di caratteri è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. + Flusso in cui scrivere. + + non è modificabile. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + + o è null. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + + o è null. + + è negativo. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + o è null. + + è negativo. + + non è modificabile. + + + Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . + true per forzare lo scaricamento del buffer; in caso contrario, false. + 1 + + + Ottiene il flusso sottostante che si interfaccia con un archivio di backup. + Flusso in cui StreamWriter scrive. + 2 + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + + + Ottiene l'oggetto in cui viene scritto l'output. + Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. + 2 + + + Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. + Il writer corrente è chiuso. + Si è verificato un errore di I/O. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive un carattere nel flusso. + Carattere da scrivere nel flusso. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una matrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una sottomatrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una stringa nel flusso. + Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Implementa un oggetto che legge da una stringa. + 2 + + + Inizializza una nuova istanza della classe che legge dalla stringa specificata. + Stringa sulla quale inizializzare . + Il parametro è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Restituisce il carattere successivo disponibile senza utilizzarlo. + Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Il lettore corrente è chiuso. + 2 + + + Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. + Il lettore corrente è chiuso. + 2 + + + Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . + Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Indice iniziale nel buffer. + Numero di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. + Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. + Il lettore corrente è chiuso. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + 2 + + + Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Contenuto dalla posizione corrente alla fine della stringa sottostante. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. + Il numero di caratteri è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il controllo di formato specificato. + Oggetto che controlla la formattazione. + + + Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. + Oggetto StringBuilder in cui scrivere. + + è null. + + + Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. + Oggetto StringBuilder in cui scrivere. + Oggetto che controlla la formattazione. + + è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Recupera l'oggetto in cui viene scritto l'output. + Encoding in cui viene scritto l'output. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di svuotamento asincrona. + + + Restituisce l'oggetto sottostante. + StringBuilder sottostante. + 2 + + + Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. + Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. + 2 + + + Scrive un carattere nella stringa. + Carattere da inserire. + Il writer è chiuso. + 2 + + + Scrive una sottomatrice di caratteri nella stringa. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + Il valore di o è negativo. + ( + )> .Length. + Il writer è chiuso. + 2 + + + Scrive una stringa nella stringa corrente. + Stringa da scrivere. + Il writer è chiuso. + 2 + + + Scrive un carattere nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nella stringa corrente in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. + 2 + + + Inizializza una nuova istanza della classe . + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. + 1 + + + Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. + Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 2 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. + Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. + Si è verificato un errore di I/O. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + La classe è chiusa. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. + Si è verificato un errore di I/O. + La classe è chiusa. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. + Il numero di caratteri è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il provider di formato specificato. + Oggetto che controlla la formattazione. + + + Archivia i caratteri di nuova riga usati per questo TextWriter. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. + Codifica caratteri in cui viene scritto l'output. + 1 + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il writer di testo viene eliminato. + Il writer è attualmente utilizzato da un'operazione di scrittura precedente. + + + Ottiene un oggetto che controlla la formattazione. + Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. + 2 + + + Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. + Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. + 2 + + + Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nella stringa o flusso di testo. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri nella stringa o flusso di testo. + Matrice di caratteri da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. + Oggetto da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa nella stringa o nel flusso di testo. + Stringa da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + + o è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso o nella stringa di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + Posizione del carattere in dalla quale avviare la lettura dei dati. + Numero massimo di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + Viene passato un oggetto o una stringa come null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml new file mode 100644 index 00000000..4114d626 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml @@ -0,0 +1,2264 @@ + + + + System.IO + + + + プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 + 2 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + 使用する文字エンコーディング。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + は null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + または が null です。 + + + + の基になるストリームへのアクセスを公開します。 + BinaryReader に関連付けられた、基になるストリーム。 + 2 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 + 読み取るバイト数。 + + 分のバイトを読み取る前にストリームの末尾に到達しました。 + I/O エラーが発生しました。 + 要求された が、内部バッファー サイズより大きくなっています。 + + + 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 + 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 + 2 + + + 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 + + に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取るバイト数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 + バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取る文字の数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 32 ビット整数を圧縮形式で読み取ります。 + 圧縮形式の 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + ストリームが破損しています。 + + + 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った次のバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 + 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + が負の値です。 + 2 + + + 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 現在のストリームから読み取った文字。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + サロゲート文字が読み取られました。 + 2 + + + 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 + 読み取る文字の数。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + + が負の値です。 + 2 + + + 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 + 現在のストリームから読み取った 10 進数値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った符号付きバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 + 読み取った文字列。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号なし整数。 + ストリームの末尾に到達しました。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 + 2 + + + ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + は null なので、 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + 使用する文字エンコーディング。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 出力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + + の基になるストリームを取得します。 + BinaryWriter に関連付けられた、基になるストリーム。 + 1 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + バッキング ストアを持たない を指定します。 + 1 + + + 基になるストリームを保持します。 + + + 現在のストリーム内の位置を設定します。 + 現在のストリームの位置。 + + からのバイト オフセット。 + 新しい位置を取得するための参照ポイントを示す フィールド。 + ファイル ポインターが無効な位置に移動しました。 + + 値が無効です。 + 1 + + + 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 + 書き込む Boolean 値 (0 または 1)。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号なしバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 基になるストリームにバイト配列を書き込みます。 + 書き込むデータが格納されているバイト配列。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は null なので、 + 1 + + + 現在のストリームにバイト配列の特定の領域を書き込みます。 + 書き込むデータが格納されているバイト配列。 + + 内の書き込み開始点。 + 書き込むバイト数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む非サロゲート Unicode 文字。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は、単一のサロゲート文字です。 + 1 + + + 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + は null なので、 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + 内の書き込み開始点。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 + 書き込む 10 進値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号付きバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む値。 + I/O エラーが発生しました。 + + は null なので、 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 32 ビット整数を圧縮形式で書き込みます。 + 書き込む 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + ストリームが閉じられました。 + + + ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 + 2 + + + メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 + + + メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データ ストリームが無効な形式である場合にスローされる例外。 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 + + + 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + 現在のストリームを作成する符号なしバイトの配列。 + + は null です。 + + + + プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + + バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + + は null です。 + + または が 0 未満です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 + バイト単位の内部配列の初期サイズ。 + + が負の値です。 + + + 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 2 + + + ストリームに割り当てられたバイト数を取得または設定します。 + ストリームに対してバッファーが使用できる部分の長さ。 + 容量が負の値または現在のストリーム長より小さい値に設定されています。 + 現在のストリームが閉じています。 + 容量を変更できないストリームに対して set が呼び出されました。 + 2 + + + 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 + キャンセル要求を監視するためのトークン。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + アクションが実行されないように、 メソッドをオーバーライドします。 + 2 + + + このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。 + ストリームは破棄されています。 + + + バイト単位のストリーム長を取得します。 + バイト単位のストリーム長。 + ストリームが閉じられました。 + 2 + + + ストリームの現在位置を取得または設定します。 + ストリーム内の現在位置。 + 位置が負の値または より大きい値に設定されています。 + ストリームが閉じられました。 + 2 + + + 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 + バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 + このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 + 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームからバイトを読み取ります。 + + にキャストしたバイト。ストリームの末尾に達した場合は -1。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム内の位置を指定した値に設定します。 + 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 + ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 + シーク参照ポイントとして機能する 型の値。 + ストリームの先頭より前をシークしようとしました。 + + が より大きくなっています。 + 無効な があります。または によって算術オーバーフローが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム長を指定した値に設定します。 + 長さを設定する値。 + 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 + + が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 + 2 + + + + プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 + 新しいバイト配列。 + 2 + + + このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 + 変換が成功した場合は true。それ以外の場合は false。 + このストリームの作成元のバイト配列セグメント。 + + + バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 + データの書き込み元となるバッファー。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリーム内の現在位置に 1 バイトを書き込みます。 + 書き込むバイト。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 + 現在のストリームが閉じています。 + 2 + + + メモリ ストリームの内容全体を別のストリームに書き込みます。 + このメモリ ストリームが書き込まれるストリーム。 + + は null です。 + 現在のストリームまたは対象のストリームは閉じています。 + 2 + + + シークに使用するストリームの場所を指定します。 + 2 + + + ストリームの先頭を指定します。 + + + ストリーム内の現在位置を指定します。 + + + ストリームの末尾を指定します。 + + + バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 + ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 + ストリームがシークをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 + 現在のストリームがタイムアウトできるかどうかを決定する値。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + によって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + I/O エラーが発生しました。 + 2 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。既定値は です。 + ストリームは破棄されています。 + + + 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 + ストリーム長 (バイト単位) を表す long 値。 + Stream から派生したクラスがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + バッキング ストアを持たない Stream。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 + ストリーム内の現在位置。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 + バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 + バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 + 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームから読み取る最大バイト数。 + + と の合計値が、バッファー長より大きい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 + Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 + 現在のストリーム内の新しい位置。 + + パラメーターからの相対バイト オフセット。 + 新しい位置を取得するために使用する参照ポイントを示す 型の値。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 + 現在のストリームの希望の長さ (バイト数)。 + I/O エラーが発生しました。 + ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 + バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームに書き込むバイト数。 + 合計  と  がバッファーの長さより大きい。 + + nullです。 + + または  が負の値です。 + 指定したファイルが見つからないなど、I/O エラーが発生しました。 + ストリームは書き込みをサポートしません。 + + ストリームが閉じられた後が呼び出されました。 + 1 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + ストリームに書き込むバイト。 + I/O エラーが発生しました。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 1 + + + 指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + + が読み取りをサポートしていません。 + + は null です。 + + + バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + は null です。 + + + 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + 最小バッファー サイズ。 + ストリームは読み取りをサポートしません。 + + または が null です。 + + が 0 以下です。 + + + 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 読み取るストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 + 最小バッファー サイズ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + + 基になるストリームを返します。 + 基になるストリーム。 + 2 + + + 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 + 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 + 2 + + + 内部バッファーをクリアします。 + 2 + + + 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 + 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 + 基になるストリームは破棄されています。 + 1 + + + 空のストリームの オブジェクト。 + 1 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 + 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 + 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みの開始位置を示す のインデックス。 + 読み取り対象の最大文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。たとえば、ストリームがクローズされています。 + 1 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 + 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + すべての文字の現在位置から末尾までを読み込みます。 + ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 + 1 + + + UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + + が書き込み可能ではありません。 + + は null です。 + + + 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + + または が null です。 + + が書き込み可能ではありません。 + + + 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + true to leave the stream open after the object is disposed; otherwise, false. + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + + が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 + + に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 + 1 + + + バッキング ストアと連結する、基になるストリームを取得します。 + この StreamWriter が書き込むストリーム。 + 2 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + + + 出力の書き込みに使用する を取得します。 + 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 + 2 + + + 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 + 現在のライターがクローズされています。 + I/O エラーが発生しました。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + 1 + + + このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 + 1 + + + ストリームに文字を書き込みます。 + ストリームに書き込む文字。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列を書き込みます。 + 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列の一部を書き込みます。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字列を書き込みます。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + I/O エラーが発生しました。 + 1 + + + 文字を非同期でストリームに書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列から読み取る を実装します。 + 2 + + + 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 + + を初期化する目的の文字列。 + + パラメーターが null です。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 + 基になる文字列の次の文字。または使用できる文字がない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 + バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + バッファー内の開始インデックス。 + 読み取る文字の数。 + + は null なので、 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + 現在のリーダーが閉じています。 + 2 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 + 現在の文字列の次の行。文字列の末尾に到達した場合は null。 + 現在のリーダーが閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 2 + + + 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 + 基になる文字列の現在位置から末尾までの内容。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 現在のリーダーが閉じています。 + 2 + + + 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + + は null なので、 + + + 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + 書式を制御する オブジェクト。 + + は null なので、 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 出力の書き込みに使用する を取得します。 + 出力の書き込み時に適用する Encoding。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + + + 基になる を返します。 + 基になる StringBuilder。 + 2 + + + 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 + 現在の StringWriter に書き込まれた文字を格納している文字列。 + 2 + + + 文字列に文字を書き込みます。 + 書き込む文字。 + ライターが閉じられました。 + 2 + + + 文字配列の一部を文字列に書き込みます。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + または が負の値です。 + ( + )> 。Length. + ライターが閉じられました。 + 2 + + + 現在の文字列に文字列を書き込みます。 + 書き込む文字列。 + ライターが閉じられました。 + 2 + + + 文字列に文字を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に文字列を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 一連の文字を読み取ることができるリーダーを表します。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り対象のデータを TextReader に提供しません。 + 1 + + + リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 + テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 2 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 + リーダーの次の行。またはすべての文字が読み取られた場合は null。 + I/O エラーが発生しました。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + + が閉じています。 + 次の行の文字数が、 を超えています。 + 1 + + + 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 + テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 + I/O エラーが発生しました。 + + が閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 次の行の文字数が、 を超えています。 + 1 + + + テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + この TextWriter で使用する改行文字を格納します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 + 出力の書き込み時に適用する文字エンコーディング。 + 1 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + テキスト ライターは破棄されます。 + ライターは現在、前の書き込み操作で使用中です。 + + + 書式を制御するオブジェクトを取得します。 + 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 + 2 + + + 現在の TextWriter で使用される行終端文字列を取得または設定します。 + 現在の TextWriter で使用する行終端文字列。 + 2 + + + バッキング ストアを持たない書き込み専用の TextWriter を提供します。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字配列をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込みます。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込むオブジェクト。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込みます。 + 書き込む文字列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + + または が null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をテキスト文字列またはストリームに書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + データの読み込みを開始する、 内の文字の位置。 + 書き込む文字の最大数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + 文字列またはオブジェクトが null として渡されました。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml new file mode 100644 index 00000000..145ab498 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml @@ -0,0 +1,2262 @@ + + + + System.IO + + + + 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. + 2 + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 가 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 또는 가 null인 경우 + + + + 의 내부 스트림에 대한 액세스를 노출합니다. + BinaryReader와 관련된 내부 스트림입니다. + 2 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. + 읽을 바이트 수입니다. + + 를 읽기 전에 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 요청된 가 내부 버퍼 크기보다 큰 경우 + + + 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. + 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. + 2 + + + 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. + + 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 압축 형식의 32비트 정수를 읽습니다. + 압축 형식의 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 스트림이 손상되었습니다. + + + 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 바이트가 0이 아니면 true이고 0이면 false입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 다음 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. + 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 현재 스트림에서 읽은 문자입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 서로게이트 문자를 읽은 경우 + 2 + + + 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. + 읽을 문자 수입니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 10진 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. + 읽어 오는 문자열입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. + 2 + + + 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 가 null입니다. + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + + 의 내부 스트림을 가져옵니다. + BinaryWriter와 관련된 내부 스트림입니다. + 1 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 1 + + + 백업 저장소가 없는 를 지정합니다. + 1 + + + 내부 스트림을 보유합니다. + + + 현재 스트림 내에서 위치를 설정합니다. + 현재 스트림에서의 위치입니다. + + 에 상대적인 바이트 오프셋입니다. + 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. + 파일 포인터가 잘못된 위치로 이동한 경우 + + 값이 잘못된 경우 + 1 + + + false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. + 쓸 Boolean 값(0 또는 1)입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 없는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 내부 스트림에 바이트 배열을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 null입니다. + 1 + + + 현재 스트림에 바이트 배열 영역을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 단일 서로게이트 문자인 경우 + 1 + + + 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + + 가 null입니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. + 출력할 10진수 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 있는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + + 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 값입니다. + I/O 오류가 발생하는 경우 + + 가 null입니다. + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 압축 형식의 32비트 정수를 씁니다. + 쓸 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + 스트림이 닫혀 있는 경우 + + + 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. + 2 + + + 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + + 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 현재 스트림을 만들 부호 없는 바이트의 배열입니다. + + 가 null인 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + + 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + + 가 null인 경우 + + 또는 가 0보다 작은 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 내부 배열의 초기 크기(바이트)입니다. + + 가 음수인 경우 + + + 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 2 + + + 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. + 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. + 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 + 현재 스트림이 닫혀 있는 경우 + 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 + 2 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. + 취소 요청을 모니터링할 토큰입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다. + 스트림이 삭제된 경우 + + + 스트림의 길이(바이트)를 가져옵니다. + 스트림의 길이(바이트)입니다. + 스트림이 닫혀 있는 경우 + 2 + + + 스트림 내의 현재 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + 위치가 음수 값이나 보다 큰 값으로 설정된 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. + 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. + 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트를 읽습니다. + + 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림 내의 위치를 지정된 값으로 설정합니다. + 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. + 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. + 검색 참조 지점 역할을 하는 형식의 값입니다. + 스트림의 시작 전에 검색하려고 한 경우 + + 가 보다 큰 경우 + 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림의 길이를 지정된 값으로 설정합니다. + 길이를 설정할 값입니다. + 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 + + 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. + 2 + + + + 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. + 새 바이트 배열입니다. + 2 + + + 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. + 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. + 이 스트림을 만든 바이트 배열 세그먼트입니다. + + + 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. + 데이터를 쓸 버퍼입니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 위치에서 현재 스트림에 바이트를 씁니다. + 쓸 바이트입니다. + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 + 현재 스트림이 닫혀 있는 경우 + 2 + + + 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. + 이 메모리 스트림을 쓸 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 닫혀 있는 경우 + 2 + + + 탐색에 사용할 스트림 내 위치를 지정합니다. + 2 + + + 스트림의 맨 앞을 지정합니다. + + + 스트림 내의 현재 위치를 지정합니다. + + + 스트림의 맨 끝을 지정합니다. + + + 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. + 2 + + + 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 에서 사용하는 모든 리소스를 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. + I/O 오류가 발생하는 경우 + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + 스트림이 삭제된 경우 + + + 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. + 스트림 길이(바이트)를 나타내는 long 값입니다. + Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 백업 저장소가 없는 Stream입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + I/O 오류가 발생하는 경우 + 스트림이 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. + 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. + 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에서 읽을 최대 바이트 수입니다. + + 와 의 합계가 버퍼 길이보다 큰 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. + Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. + 현재 스트림 내의 새 위치입니다. + + 매개 변수에 상대적인 바이트 오프셋입니다. + 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. + 원하는 현재 스트림의 길이(바이트)입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. + 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에 쓸 바이트 수입니다. + 총  및  버퍼 길이 보다 큽니다. + + null입니다. + + 또는  음수입니다. + 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. + 스트림이 쓰기를 지원하지 않습니다. + + 스트림이 닫힌 후 호출 되었습니다. + 1 + + + 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. + 스트림에 쓸 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 1 + + + 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + 최소 버퍼 크기입니다. + 스트림이 읽기를 지원하지 않습니다. + + 또는 가 null인 경우 + + 가 0보다 작거나 같은 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. + 최소 버퍼 크기입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + + + 내부 스트림을 반환합니다. + 내부 스트림입니다. + 2 + + + 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. + 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. + 2 + + + 내부 버퍼를 지웁니다. + 2 + + + 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. + 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. + 내부 스트림이 삭제된 경우 + 1 + + + 빈 스트림 주위의 개체입니다. + 1 + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + + 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. + 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 인덱스입니다. + 읽을 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫히는 등의 I/O 오류가 발생한 경우 + 1 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. + 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + + 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. + 1 + + + UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + + 에 쓸 수 없는 경우 + + 가 null인 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + + 또는 가 null인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + true to leave the stream open after the object is disposed; otherwise, false. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + + 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. + + 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. + 1 + + + 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. + 이 StreamWriter가 쓰고 있는 스트림입니다. + 2 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + + + 출력이 쓰여질 을 가져옵니다. + 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. + 2 + + + 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. + 현재 writer가 닫힌 경우 + I/O 오류가 발생한 경우 + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + 1 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. + 1 + + + 스트림에 문자를 씁니다. + 스트림에 쓸 문자입니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자의 하위 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자열을 씁니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작할 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 줄 종결자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열에서 읽어오는 를 구현합니다. + 2 + + + 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. + + 가 초기화되어야 하는 문자열입니다. + + 매개 변수가 null인 경우 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 버퍼의 시작 인덱스입니다. + 읽을 문자 수입니다. + + 가 null입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. + 현재 판독기가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 2 + + + 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. + 내부 문자열의 현재 위치에서 끝까지의 내용입니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 형식 지정을 제어하는 개체입니다. + + + 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + + 가 null입니다. + + + 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + 형식 지정을 제어하는 개체입니다. + + 가 null입니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 출력이 쓰여질 을 가져옵니다. + 출력이 쓰여질 Encoding입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 비동기 플러시 작업을 나타내는 작업입니다. + + + 내부 를 반환합니다. + 내부 StringBuilder입니다. + 2 + + + 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. + 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. + 2 + + + 문자를 문자열에 씁니다. + 쓸 문자입니다. + 작성기가 닫힌 경우 + 2 + + + 문자의 하위 배열을 문자열에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 또는 가 음수인 경우 + ( + )> 인 경우Length. + 작성기가 닫힌 경우 + 2 + + + 문자를 현재 문자열에 씁니다. + 쓸 문자열입니다. + 작성기가 닫힌 경우 + 2 + + + 문자를 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자를 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + TextReader에 읽을 데이터를 제공하지 않습니다. + 1 + + + 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. + I/O 오류가 발생하는 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + + 가 닫힌 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. + I/O 오류가 발생하는 경우 + + 가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 서식 지정을 제어하는 개체입니다. + + + 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. + 출력을 쓰는 문자 인코딩입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. + + + 서식 지정을 제어하는 개체를 가져옵니다. + 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. + 2 + + + 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. + 현재 TextWriter의 줄 종결자 문자열입니다. + 2 + + + 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. + 1 + + + Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + + 또는 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + 데이터 읽기를 시작하는 의 문자 위치입니다. + 쓸 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + 문자열이나 개체가 null로 전달되는 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml new file mode 100644 index 00000000..d9ad6103 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml @@ -0,0 +1,2023 @@ + + + + System.IO + + + + Считывает примитивные типы данных как двоичные значения в заданной кодировке. + 2 + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Входной поток. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. + Входной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Входной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Параметр или имеет значение null. + + + Предоставляет доступ к базовому потоку объекта . + Базовый поток, связанный с объектом BinaryReader. + 2 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. + Количество байтов, чтение которых необходимо выполнить. + Конец потока достигнут раньше, чем было выполнено чтение байтов. + Ошибка ввода-вывода. + Запрошенное значение превышает размер внутреннего буфера. + + + Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. + Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. + Ошибка ввода-вывода. + Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. + 2 + + + Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. + Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Количество байтов, чтение которых необходимо выполнить. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. + Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Число символов для чтения. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число в сжатом формате. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Поток поврежден. + + + Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. + Значение true, если байт не равен нулю; в противном случае — значение false. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. + Следующий байт, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. + Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. + Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Ошибка ввода-вывода. + Поток закрыт. + Значение отрицательно. + 2 + + + Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Символ, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Выполнено чтение символа-заместителя. + 2 + + + Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. + Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. + Количество символов, которое необходимо считать. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Поток закрыт. + Ошибка ввода-вывода. + Значение отрицательно. + 2 + + + Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. + Десятичное значение, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Число с плавающей запятой длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Целое число со знаком длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. + Байт со знаком, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Число с плавающей запятой длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. + Считываемая строка. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число без знака длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число без знака длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. + Целое число без знака длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. + 2 + + + Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Выходной поток. + Поток не поддерживает запись или был закрыт до начала операции. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. + Выходной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Выходной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Получает базовый поток . + Базовый поток, связанный с объектом BinaryWriter. + 1 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Задает без резервного хранилища. + 1 + + + Содержит базовый поток. + + + Задает позицию в текущем потоке. + Позиция в текущем потоке. + Смещение в байтах относительно . + Поле указывает точку отсчета, относительно которой указывается новая позиция. + Указатель позиции в файле перемещен в недопустимую позицию. + Значение является недопустимым. + 1 + + + Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. + Записываемое в поток значение типа Boolean (0 или 1). + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. + Записываемый в поток байт без знака. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись массива байтов в базовый поток. + Массив байтов, содержащий записываемые в поток данные. + Ошибка ввода-вывода. + Поток закрыт. + Параметр имеет значение null. + 1 + + + Выполняет запись части массива байтов в текущий поток. + Массив байтов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество записываемых байтов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. + Незаменяющий символ Юникода, который необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + + представляет собой единичный символ-заместитель. + 1 + + + Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. + Массив символов, содержащий записываемые в поток данные. + Параметр имеет значение null. + Поток закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. + Массив символов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. + Десятичное значение, которое необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число со знаком размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число со знаком размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число со знаком размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. + Байт со знаком, который необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. + Записываемое значение. + Ошибка ввода-вывода. + Параметр имеет значение null. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число без знака размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число без знака размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число без знака размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число, которое необходимо записать. + Достигнут конец потока. + Поток закрыт. + Поток закрыт. + + + Исключение, которое создается при попытке выполнить чтение за пределами потока. + 2 + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Исключение возникает, когда поток данных имеет недопустимый формат. + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. + Массив байтов без знака, из которого создается текущий поток. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Свойство имеет значение null. + Значение параметра или меньше нуля. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + Параметр или имеет отрицательное значение. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. + Исходный размер внутреннего массива в байтах. + Значение отрицательно. + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 2 + + + Возвращает или задает число байтов, выделенных для этого потока. + Длина применимой к использованию части буфера для потока. + Заданная емкость отрицательная или меньше текущей длины потока. + Текущий поток закрыт. + set вызывается для потока, емкость которого нельзя изменить. + 2 + + + Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля. + Токен для отслеживания запросов отмены. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Переопределяет метод так, что никакие действия не выполняются. + 2 + + + Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены. + Поток был ликвидирован. + + + Возвращает длину потока в байтах. + Длина потока в байтах. + Поток закрыт. + 2 + + + Возвращает или задает текущее положение в потоке. + Текущее положение в потоке. + В качестве положения задано отрицательное значение или значение, большее . + Поток закрыт. + 2 + + + Считывает блок байтов из текущего потока и записывает данные в буфер. + Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. + При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом меньше, чем . + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из текущего потока. + Байт приводится к типу или -1, если достигнут конец потока. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для положения в текущем потоке. + Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. + Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. + Значение типа , которое действует как точка ссылки поиска. + Попытка поиска выполняется до начала потока. + Значение больше значения . + + недопустим. -или-Значение вызвало арифметическое переполнение. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для длины текущего потока. + Значение задаваемой длины. + Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. + Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. + 2 + + + Записывает содержимое потока в массив байтов независимо от свойства . + Новый массив байтов. + 2 + + + Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. + Значение true, если преобразование прошло успешно; в противном случае — значение false. + Сегмент массива байтов, из которого был создан данный поток. + + + Записывает в текущий поток блок байтов, используя данные, считанные из буфера. + Буфер, из которого записываются данные. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. + Длина буфера за вычетом меньше, чем . + Параметр или имеет отрицательное значение. + Ошибка ввода-вывода. + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение текущего потока. + Записываемый байт. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. + Текущий поток закрыт. + 2 + + + Записывает все содержимое данного потока памяти в другой поток. + Поток, в который требуется осуществить запись данного потока памяти. + Свойство имеет значение null. + Текущий или конечный поток закрыт. + 2 + + + Задает позицию в потоке, используемую для поиска. + 2 + + + Задает начало потока. + + + Задает текущее положение в потоке. + + + Задает конец потока. + + + Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса . + + + При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. + Значение true, если поток поддерживает чтение; в противном случае — значение false. + 1 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. + Значение true, если поток поддерживает поиск; в противном случае — значение false. + 1 + + + Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. + Значение, которое показывает, может ли для данного потока истечь время ожидания. + 2 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 1 + + + Считывает байты из текущего потока и записывает их в другой поток. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Поток, в который будет скопировано содержимое текущего потока. + Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает все ресурсы, занятые модулем . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. + Ошибка ввода-вывода. + 2 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Поток был ликвидирован. + + + При переопределении в производном классе получает длину потока в байтах. + Длинное значение, представляющее длину потока в байтах. + Класс, созданный на основе класса Stream, не поддерживает возможность поиска. + Методы были вызваны после закрытия потока. + 1 + + + Объект Stream без резервного хранилища. + 1 + + + При переопределении в производном классе получает или задает позицию в текущем потоке. + Текущее положение в потоке. + Ошибка ввода-вывода. + Этот поток не поддерживает поиск. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. + Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. + Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. + Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. + Максимальное количество байтов, которое должно быть считано из текущего потока. + Сумма значений параметров и больше длины буфера. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 1 + + + Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. + Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + При переопределении в производном классе задает позицию в текущем потоке. + Новая позиция в текущем потоке. + Смещение в байтах относительно параметра . + Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. + Ошибка ввода-вывода. + Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе задает длину текущего потока. + Нужная длина текущего потока в байтах. + Ошибка ввода-вывода. + Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 2 + + + При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. + Массив байтов.Этот метод копирует байты из в текущий поток. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Количество байтов, которое необходимо записать в текущий поток. + Сумма  и  больше, чем длина буфера. + + — null. + + или  является отрицательным. + Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. + Поток не поддерживает запись. + + был вызван после закрытия потока. + 1 + + + Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. + Байт, записываемый в поток. + Ошибка ввода-вывода. + Поток не поддерживает запись или был закрыт до начала операции. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 1 + + + Инициализирует новый экземпляр класса для заданного потока. + Поток, который нужно считать. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. + Поток, который нужно считать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + Минимальный размер буфера. + Поток не поддерживает чтение. + Параметр или имеет значение null. + Значение параметра меньше или равно нулю. + + + Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. + Считываемый поток. + Кодировка символов, которую нужно использовать. + Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. + Минимальный размер буфера. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + + + Возвращает основной поток. + Основной поток. + 2 + + + Возвращает текущую кодировку символов, используемую текущим объектом . + Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. + 2 + + + Очищает внутренний буфер. + 2 + + + Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. + Значение true, если текущее положение находится в конце потока; в противном случае — значение false. + Основной поток удален. + 1 + + + Объект для пустого потока. + 1 + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. + Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. + Ошибка ввода-вывода. + 1 + + + Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. + Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Индекс , с которого требуется начать запись. + Максимальное число считываемых символов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Возникает ошибка ввода-вывода, например закрывается поток. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Произошла ошибка ввода-вывода. + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Следующая строка из входного потока или значение null, если достигнут конец входного потока. + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. + Количество символов в следующей строке больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца потока. + Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. + Количество символов больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. + 1 + + + Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Запись в поток запрещена. + + is null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Значение параметра или — null. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . + Значение true, чтобы заставить сбросить буфер; в противном случае — false. + 1 + + + Получает основной поток, связанный с резервным хранилищем. + Поток, в который StreamWriter выполняет запись. + 2 + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. + 2 + + + Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. + Текущее средство записи закрывается. + Произошла ошибка ввода-вывода. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + 1 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает символ в поток. + Символ, записываемый в поток. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток массив символов. + Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток дочерний массив символов. + Массив символов, содержащий записываемые данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток строку. + Строка, записываемая в поток.Если равняется null, запись не выполняется. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает символ в поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, содержащий записываемые данные. + Положение символа в буфере с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает строку в поток. + Задача, представляющая асинхронную операцию записи. + Строка, записываемая в поток.Если имеет значение null, запись не выполняется. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток признак конца строки. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Реализует класс , осуществляющий чтение из строки. + 2 + + + Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. + Строка, для которой должен быть инициализирован класс . + Значение параметра — null. + + + Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. + Текущее средство чтения закрыто. + 2 + + + Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. + Следующий символ из основной строки или значение -1, если больше нет доступных символов. + Текущее средство чтения закрыто. + 2 + + + Считывает блок символов из строки ввода и увеличивает позицию символов на . + Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Начальный индекс в буфере. + Количество символов, которые необходимо считать. + Параметр имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Следующая строка из текущей строки, или значение null, если достигнут конец строки. + Текущее средство чтения закрыто. + Недостаточно памяти для размещения буфера возвращаемых строк. + 2 + + + Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Содержимое, начиная от текущей позиции до конца основной строки. + Недостаточно памяти для размещения буфера возвращаемых строк. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. + Количество символов больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи данных в строку.Данные хранятся в основном . + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным форматом объекта. + Объект , управляющий форматированием. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . + Класс StringBuilder, в который осуществляется запись. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. + Класс StringBuilder, в который осуществляется запись. + Объект , управляющий форматированием. + Параметр имеет значение null. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Encoding, в которой осуществляется запись выходных данных. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + + + Возвращает основной . + Базовый StringBuilder. + 2 + + + Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. + Строка, содержащая символы, записанные в текущий StringWriter. + 2 + + + Записывает символ в строку. + Символ для записи. + Средство записи закрыто. + 2 + + + Записывает в строку дочерний массив символов. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Значение параметра или является отрицательным. + ( + )> .Length. + Средство записи закрыто. + 2 + + + Записывает строку в текущую строку. + Строка для записи. + Средство записи закрыто. + 2 + + + Выполняет асинхронную запись символа в строку. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в строку. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текущую строку. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в строку символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Представляет средство чтения, позволяющее считывать последовательные наборы символов. + 2 + + + Инициализирует новый экземпляр класса . + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Предоставляет TextReader без данных, доступных для чтения. + 1 + + + Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. + Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. + При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. + Следующая строка из средства чтения, или значение null, если все символы считаны. + Ошибка ввода-вывода. + Недостаточно памяти для размещения буфера возвращаемых строк. + Объект закрыт. + Количество символов в следующей строке больше . + 1 + + + Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. + Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. + Ошибка ввода-вывода. + Объект закрыт. + Недостаточно памяти для размещения буфера возвращаемых строк. + Количество символов в следующей строке больше . + 1 + + + Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. + Количество символов больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса указанным поставщиком формата. + Объект , управляющий форматированием. + + + Сохраняет символы новой строки, используемые для данного TextWriter. + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. + Кодировка символов, в которой осуществляется запись выходных данных. + 1 + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Удалено средство записи текста. + Средство записи в настоящее время используется предыдущей операцией записи. + + + Возвращает объект, управляющий форматированием. + Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. + 2 + + + Возвращает или задает признак конца строки, используемой текущим TextWriter. + Признак конца строки для текущего TextWriter. + 2 + + + Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись символа в текстовую строку или поток. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись массива символов в текстовую строку или поток. + Массив символов, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает дочерний массив символов в текстовую строку или поток. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает текстовое представление десятичного значения в текстовую строку или поток. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. + Записываемый объект. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает строку в текстовую строку или поток. + Строка для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Параметр или имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет асинхронную запись символа в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись массива символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Записывает признак конца строки в текстовую строку или поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Положение символа в , с которого начинается чтение данных. + Наибольшее количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. + Записываемый объект.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток строку, за которой следует признак конца строки. + Строка для записи.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Строка или объект передаются в виде null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает признак конца строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml new file mode 100644 index 00000000..cf7eb52f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml @@ -0,0 +1,2237 @@ + + + + System.IO + + + + 用特定的编码将基元数据类型读作二进制值。 + 2 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输入流。 + 该流不支持读取，为null 或已关闭。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输入流。 + 要使用的字符编码。 + 该流不支持读取，为null 或已关闭。 + + 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输入流。 + 要使用的字符编码。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + 该流不支持读取，为null 或已关闭。 + + 或 为 null。 + + + 公开对 的基础流的访问。 + 与 BinaryReader 关联的基础流。 + 2 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 用从流中读取的指定字节数填充内部缓冲区。 + 要读取的字节数。 + 在可以读取 之前到达了流的末尾。 + 发生 I/O 错误。 + 请求的 大于内部缓冲区大小。 + + + 返回下一个可用的字符，并且不提升字节或字符的位置。 + 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 + 发生 I/O 错误。 + 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 + 2 + + + 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 输入流中的下一个字符，如果当前无可用字符则为 -1。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 从字节数组中的指定点开始，从流中读取指定的字节数。 + 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字节数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从字符数组中的指定点开始，从流中读取指定的字符数。 + 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字符数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 以压缩格式读入 32 位整数。 + 压缩格式的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 流已损坏。 + + + 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 + 如果字节为非零，则为 true，否则为 false。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的下一个字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 + 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 发生 I/O 错误。 + 流已关闭。 + + 为负数。 + 2 + + + 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 从当前流中读取的字符。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 读取了一个代理项字符。 + 2 + + + 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 + 要读取的字符数。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 流已关闭。 + 发生 I/O 错误。 + + 为负数。 + 2 + + + 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 + 从当前流中读取的十进制数值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的一个有符号字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 4 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 + 正被读取的字符串。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 + 从该流中读取的 2 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 + 从该流中读取的 4 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 + 从该流中读取的 8 字节无符号整数。 + 已到达流的末尾。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 + 2 + + + 初始化向流中写入的 类的新实例。 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输出流。 + 该流不支持写入或者该流已关闭。 + + 为 null。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输出流。 + 要使用的字符编码。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输出流。 + 要使用的字符编码。 + 如果在释放 对象之后打开流对象，则为 true；否则为， false。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 获取 的基础流。 + 与 BinaryWriter 关联的基础流。 + 1 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 指定无后备存储区的 。 + 1 + + + 持有基础流。 + + + 设置当前流中的位置。 + 包含当前流的位置。 + 相对于 的字节偏移量。 + + 的一个字段，指示获取新位置所依据的参考点。 + 文件指针被移到无效位置。 + + 值无效。 + 1 + + + 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 + 要写入的 Boolean 值（0 或 1）。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的无符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将字节数组写入基础流。 + 包含要写入的数据的字节数组。 + 发生 I/O 错误。 + 流已关闭。 + + 为 null。 + 1 + + + 将字节数组部分写入当前流。 + 包含要写入的数据的字节数组。 + + 中开始写入的起始点。 + 要写入的字节数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 要写入的非代理项 Unicode 字符。 + 发生 I/O 错误。 + 流已关闭。 + + 是单一代理项字符。 + 1 + + + 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 为 null。 + 流已关闭。 + 发生 I/O 错误。 + 1 + + + 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 中开始写入的起始点。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个十进制值写入当前流，并将流位置提升十六个字节。 + 要写入的十进制值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的有符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 + 要写入的值。 + 发生 I/O 错误。 + + 为 null。 + 流已关闭。 + 1 + + + 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 以压缩格式写出 32 位整数。 + 要写出的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 流已关闭。 + + + 读操作试图超出流的末尾时引发的异常。 + 2 + + + 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + + + 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 在数据流的格式无效时引发的异常。 + + + 初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 用对作为此异常原因的内部异常的引用初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化为零的可扩展容量初始化 类的新实例。 + + + 基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建当前流的无符号字节数组。 + + 为 null。 + + + 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + + 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 为 null。 + + 或 小于零。 + 缓冲区长度减去 小于 。 + + + 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 使用按指定要求初始化的可扩展容量初始化 类的新实例。 + 内部数组的初始大小（以字节为单位）。 + + 为负数。 + + + 获取一个值，该值指示当前流是否支持读取。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持查找。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持写入。 + 如果流支持写入，则为 true；否则为 false。 + 2 + + + 获取或设置分配给该流的字节数。 + 流的缓冲区的可使用部分的长度。 + 容量设置为负或小于流的当前长度。 + 当前流已关闭。 + 对不能修改其容量的流调用 set。 + 2 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。 + 要监视取消请求的标记。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 重写 方法以便不执行任何操作。 + 2 + + + 异步清除此流的所有缓冲区，并监视取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。 + 流已被释放。 + + + 获取流的长度（以字节为单位）。 + 流的长度（以字节为单位）。 + 流已关闭。 + 2 + + + 获取或设置流中的当前位置。 + 流中的当前位置。 + 此位置设置为负值或大于 的值。 + 流已关闭。 + 2 + + + 从当前流中读取字节块并将数据写入缓冲区。 + 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 + 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 + + 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 的结果小于 。 + 当前流实例已关闭。 + 2 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流中读取一个字节。 + 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 + 当前流实例已关闭。 + 2 + + + 将当前流中的位置设置为指定值。 + 流内的新位置，通过将初始引用点和偏移量合并计算而得。 + 流内的新位置。它是相对于 参数的位置，而且可正可负。 + 类型 的值，它用作查找引用点。 + 试图在流的开始位置之前查找。 + + 大于 。 + + 无效。- 或 - 导致算法溢出。 + 当前流实例已关闭。 + 2 + + + 将当前流的长度设为指定值。 + 用于设置长度的值。 + 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 + + 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 + 2 + + + 将流内容写入字节数组，而与 属性无关。 + 新的字节数组。 + 2 + + + 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 + 如果转换成功，则为 true；否则为 false。 + 用于创建此流的字节数组段。 + + + 使用从缓冲区读取的数据将字节块写入当前流。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 最多写入的字节数。 + + 为 null。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 + 缓冲区长度减去 的结果小于 。 + + 或 为负。 + 发生 I/O 错误。 + 当前流实例已关闭。 + 2 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入当前位置上的当前流。 + 要写入的字节。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 + 当前流已关闭。 + 2 + + + 将此内存流的整个内容写入到另一个流中。 + 要写入此内存流的流。 + + 为 null。 + 当前流或目标流已关闭。 + 2 + + + 指定在流的位置以查找使用。 + 2 + + + 指定流的开头。 + + + 指定流内的当前位置。 + + + 指定流的结尾。 + + + 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 类的新实例。 + + + 当在派生类中重写时，获取指示当前流是否支持读取的值。 + 如果流支持读取，为 true；否则为 false。 + 1 + + + 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 + 如果流支持查找，为 true；否则为 false。 + 1 + + + 获取一个值，该值确定当前流是否可以超时。 + 一个确定当前流是否可以超时的值。 + 2 + + + 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 + 如果流支持写入，则为 true；否则为 false。 + 1 + + + 从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + 缓冲区的大小。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放由 使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 + 发生 I/O 错误。 + 2 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。默认值为 。 + 流已被释放。 + + + 当在派生类中重写时，获取流长度（以字节为单位）。 + 表示流长度（以字节为单位）的长值。 + 从 Stream 派生的类不支持查找。 + 在流关闭后调用方法。 + 1 + + + 无后备存储区的 Stream。 + 1 + + + 当在派生类中重写时，获取或设置当前流中的位置。 + 流中的当前位置。 + 发生 I/O 错误。 + 流不支持查找。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 + 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 + 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 + + 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 + 要从当前流中最多读取的字节数。 + + 与 的和大于缓冲区长度。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流不支持读取。 + 在流关闭后调用方法。 + 1 + + + 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 + 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 + 流不支持读取。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 + 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 当在派生类中重写时，设置当前流中的位置。 + 当前流中的新位置。 + 相对于 参数的字节偏移量。 + + 类型的值，指示用于获取新位置的参考点。 + 发生 I/O 错误。 + 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，设置当前流的长度。 + 所需的当前流的长度（以字节表示）。 + 发生 I/O 错误。 + 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 2 + + + 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 + 字节数组。此方法将 个字节从 复制到当前流。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 要写入当前流的字节数。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 流不支持写入。 + + 流关闭后调用。 + 1 + + + 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 + 要写入流中的字节。 + 发生 I/O 错误。 + 该流不支持写入，或者该流已关闭。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 + 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 为指定的流初始化 类的新实例。 + 要读取的流。 + + 不支持读取。 + + 为 null。 + + + 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 + 要读取的流。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 为 null。 + + + 用指定的字符编码为指定的流初始化 类的一个新实例。 + 要读取的流。 + 要使用的字符编码。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + 最小缓冲区大小。 + 流不支持读取。 + + 或 为 null。 + + 小于或等于零。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 + 要读取的流。 + 要使用的字符编码。 + 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 + 最小缓冲区大小。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + + + 返回基础流。 + 基础流。 + 2 + + + 获取当前 对象正在使用的当前字符编码。 + 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 + 2 + + + 清除内部缓冲区。 + 2 + + + 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 获取一个值，该值指示当前的流位置是否在流结尾。 + 如果当前流位置位于流的末尾，则为 true；否则为 false。 + 基础流已释放。 + 1 + + + 空流周围的 。 + 1 + + + 返回下一个可用字符，但不使用它。 + 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 + 发生 I/O 错误。 + 1 + + + 读取输入流中的下一个字符并使该字符位置提升一个字符。 + 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 + 发生 I/O 错误。 + 1 + + + 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 + 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 开始写入的 的索引。 + 要读取的最大字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 出现 I/O 错误，如流被关闭。 + 1 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生了 I/O 错误。 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取一行字符并将数据作为字符串返回。 + 输入流中的下一行；如果到达了输入流的末尾，则为 null。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 从当前流中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 + 下一行中的字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取来自流的当前位置到结尾的所有字符。 + 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 + 字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 + 1 + + + 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 + 要写入的流。 + + 不可写。 + + 为 null。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + + 或 为 null。 + + 不可写。 + + + 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + true to leave the stream open after the object is disposed; otherwise, false. + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 + 强制 刷新其缓冲区时，为 true；否则，为 false。 + 1 + + + 获取同后备存储连接的基础流。 + 此 StreamWriter 正在写入的基础流。 + 2 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + 当前编码不支持显示半个 Unicode 代理项对。 + + + 获取将输出写入到其中的 。 + 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 + 2 + + + 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 + 当前编写器已关闭。 + 出现 I/O 错误。 + 当前编码不支持显示半个 Unicode 代理项对。 + 1 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将字符写入流。 + 要写入流中的字符。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符数组写入流。 + 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符的子数组写入流。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符串写入流。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 发生 I/O 错误。 + 1 + + + 将字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将行终止符异步写入该流。 + 表示异步写操作的任务。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 实现从字符串进行读取的 。 + 2 + + + 初始化从指定字符串进行读取的 类的新实例。 + 应将 初始化为的字符串。 + + 参数为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 返回下一个可用的字符，但不使用它。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 + 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的字符块，并将字符位置提升 。 + 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 缓存区中的起始索引。 + 要读取的字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 当前读取器已关闭。 + 2 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前字符串中读取一行字符并将数据作为字符串返回。 + 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 + 当前读取器已关闭。 + 内存不足，无法为返回的字符串分配缓冲区。 + 2 + + + 从当前字符串中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 从当前位置到基础字符串的结尾之间的内容。 + 内存不足，无法为返回的字符串分配缓冲区。 + 当前读取器已关闭。 + 2 + + + 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 + 字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式控制初始化 类的新实例。 + 控制格式设置的 对象。 + + + 初始化写入指定 的 类的新实例。 + 要写入的 StringBuilder。 + + 为 null。 + + + 初始化写入指定 并具有指定格式提供程序的 类的新实例。 + 要写入的 StringBuilder。 + 控制格式设置的 对象。 + + 为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 获取将输出写入到其中的 。 + 用来写入输出的 Encoding。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + + + 返回基础 。 + 基础 StringBuilder。 + 2 + + + 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 + 包含写入到当前 StringWriter 中的字符的字符串。 + 2 + + + 将字符写入该字符串。 + 要写入的字符。 + 编写器已关闭。 + 2 + + + 将字符的子数组写入该字符串。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + 或 为负。 + ( + )> 。Length. + 编写器已关闭。 + 2 + + + 将字符串写入当前流。 + 要写入的字符串。 + 编写器已关闭。 + 2 + + + 以异步方式将字符写入流。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将字符串写入当前流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将后跟行结束符的字符写入该字符串。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将一后跟行结束符的字符串异步写入当前字符串。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 表示可读取有序字符系列的读取器。 + 2 + + + 初始化 类的新实例。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + 提供一个无数据可供读取的 TextReader。 + 1 + + + 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 + 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 + 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 2 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从文本读取器中读取一行字符并将数据作为字符串返回。 + 读取器中的下一行，或为 null （如果已读取了所有字符）。 + 发生 I/O 错误。 + 内存不足，无法为返回的字符串分配缓冲区。 + + 是关闭的。 + 下一行中的字符数大于 + 1 + + + 异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 + 发生 I/O 错误。 + + 是关闭的。 + 内存不足，无法为返回的字符串分配缓冲区。 + 下一行中的字符数大于 + 1 + + + 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 + 字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 表示可以编写一个有序字符系列的编写器。此类为抽象类。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式提供程序初始化 类的新实例。 + 控制格式设置的 对象。 + + + 存储用于此 TextWriter 的换行符。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，返回用来写输出的该字符编码。 + 用来写入输出的字符编码。 + 1 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + 文本编写器已被释放。 + 编写器正在由其前一次写操作使用。 + + + 获取控制格式设置的对象。 + 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 + 2 + + + 获取或设置由当前 TextWriter 使用的行结束符字符串。 + 当前 TextWriter 的行结束符字符串。 + 2 + + + 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符写入该文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符数组写入该文本字符串或流。 + 要写入文本流中的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符的子数组写入文本字符串或流。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符串写入到文本字符串或流。 + 要写入的字符串。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + + 或 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符写入到下一个文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符数组写入到下一个字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符串写入到下一字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将行结束符的字符串写入文本字符串或流。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符写入文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符数组写入文本字符串或流。 + 从其读取数据的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符子数组写入文本字符串或流。 + 从其读取数据的字符数组。 + 在开始读取数据时 中的字符位置。 + 要写入的最大字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符串写入文本字符串或流。 + 要写入的字符串。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + 字符串或对象作为 null 传入。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml new file mode 100644 index 00000000..26192a9d --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml @@ -0,0 +1,2246 @@ + + + + System.IO + + + + 以特定的編碼方式，將基本資料型別當做二進位值讀取。 + 2 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸入資料流。 + 資料流不支援讀取，為 null，或已經關閉。 + + + 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 + 輸入資料流。 + 要使用的字元編碼。 + 資料流不支援讀取，為 null，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + 資料流不支援讀取，為 null，或已經關閉。 + + 或 為 null。 + + + 公開 之基礎資料流的存取。 + 與 BinaryReader 相關聯的基礎資料流。 + 2 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 將從資料流讀取的指定位元組數目填入內部緩衝區。 + 要讀取的位元組數。 + 在 可讀取之前到達資料流末端。 + 發生 I/O 錯誤。 + 所要求的 大於內部緩衝區大小。 + + + 傳回下一個可用字元，而不前移位元組或字元的位置。 + 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 + 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 + 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的位元組數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 由字元陣列中的指定點開始，從資料流讀取指定字元數。 + 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的字元數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以壓縮格式讀取 32 位元整數。 + 壓縮格式的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 資料流已損毀。 + + + 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 + 如果位元組為非零值，則為 true；否則為 false。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 + 自目前資料流讀取的下一個位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 + 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 + 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為負值。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 + 自目前資料流讀取的字元。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 讀取到 Surrogate 字元 + 2 + + + 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 + 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 + 要讀取的字元數。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 已關閉資料流。 + 發生 I/O 錯誤。 + + 為負值。 + 2 + + + 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 + 自目前資料流讀取的十進位值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自目前資料流讀取的 2 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 + 自資料流讀取的帶正負號的位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 + 讀取的字串。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自這個資料流讀取 2 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自這個資料流讀取 4 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自這個資料流讀取 8 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 + 2 + + + 初始化 類別的新執行個體，其將寫入資料流。 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 資料流不支援寫入，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 要使用的字元編碼。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 輸出資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 取得 的基礎資料流。 + 與 BinaryWriter 相關聯的基礎資料流。 + 1 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 指定沒有備份存放區的 。 + 1 + + + 容納基礎資料流。 + + + 設定目前資料流位置。 + 目前資料流的位置。 + 相對於 的位元組位移。 + + 的欄位，表示要取得新位置的參考點。 + 檔案指標已移至無效的位置。 + + 值是無效的。 + 1 + + + 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 + 要寫入的 Boolean 值 (0 或 1)。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的不帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將位元組陣列寫入基礎資料流。 + 含有要寫入之資料的位元組陣列。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為 null。 + 1 + + + 將一個區域的位元組陣列寫入目前資料流。 + 含有要寫入之資料的位元組陣列。 + + 中要開始寫入的起始點。 + 要寫入的位元組數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 非 Surrogate，要寫入的 Unicode 字元。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 是單一 Surrogate 字元。 + 1 + + + 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 為 null。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 中要開始寫入的起始點。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 + 要寫入的十進位值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 要寫入的值。 + 發生 I/O 錯誤。 + + 為 null。 + 已關閉資料流。 + 1 + + + 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組不帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 以壓縮格式寫入 32 位元整數。 + 要寫入的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 已關閉資料流。 + + + 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 + 2 + + + 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + + + 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 資料流在格式無效時擲回的例外狀況。 + + + 初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 + + + 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 + 用於建立目前資料流之不帶正負號位元組的陣列。 + + 為 null。 + + + 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + + 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 為 null。 + + 或 小於零。 + 緩衝區長度減去 小於 。 + + + 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 + 內部陣列的初始大小，以位元組為單位。 + + 為負值。 + + + 取得表示目前資料流是否支援讀取的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援搜尋的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援寫入的值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 2 + + + 取得或設定配置給這個資料流的位元組數目。 + 資料流緩衝區可使用部分的長度。 + 設定的容量為負數或小於資料流目前的長度。 + 目前的資料流已經關閉。 + set 在無法修改其容量的資料流上被叫用 (Invoke)。 + 2 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 + 用來監視是否有取消要求的語彙基元。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 覆寫 方法，以便不執行任何動作。 + 2 + + + 非同步清除這個資料流的所有緩衝區，並監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。 + 已處置資料流。 + + + 取得資料流的長度，以位元組為單位。 + 資料流的長度，以位元組為單位。 + 已關閉資料流。 + 2 + + + 取得或設定資料流中目前的位置。 + 在資料流的目前位置。 + 位置設為負數值或大於 的值。 + 已關閉資料流。 + 2 + + + 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 + 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 + + 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + 緩衝區的長度減去 小於 。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從目前的資料流讀取位元組。 + 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流中的位置設定為指定的數值。 + 資料流中的新位置，是組合初始的參考點和位移計算出來的。 + 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 + + 類型的值，做為搜尋參考點。 + 在資料流開頭之前嘗試搜尋。 + + 大於 。 + 有無效的 。-或- 造成了算術溢位。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流的長度設定為指定的數值。 + 要設定長度的數值。 + 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 + + 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 + 2 + + + 不論 屬性為何，將資料流內容寫入位元組陣列。 + 新的位元組陣列。 + 2 + + + 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 + 如果轉換成功，則為 true；否則為 false。 + 從其中建立此資料流的位元組陣列區段。 + + + 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入的最大位元組數。 + + 為 null。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 + 緩衝區的長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入位元組至資料流目前位置。 + 要寫入的位元組。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 + 目前的資料流已經關閉。 + 2 + + + 將這個記憶體資料流的整個內容寫入另一個資料流。 + 要寫入這個記憶體資料流的資料流。 + + 為 null。 + 目前的資料流或目標資料流已經關閉。 + 2 + + + 指定資料流中要用於搜尋的位置。 + 2 + + + 指定資料流的開端。 + + + 指定資料流中的目前位置。 + + + 指定資料流的末端。 + + + 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 類別的新執行個體。 + + + 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 + 如果資料流支援讀取，則為 true；否則為 false。 + 1 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 + 如果資料流支援搜尋，則為 true；否則為 false。 + 1 + + + 取得值，該值判斷目前的資料流是否可以逾時。 + 值，判斷目前的資料流是否可以逾時。 + 2 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 1 + + + 從目前資料流讀取位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 所使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 發生 I/O 錯誤。 + 2 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 已處置資料流。 + + + 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + 已處置資料流。 + + + 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 + 代表資料流長度的長數值 (以位元組為單位)。 + 衍生自 Stream 的類別不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 沒有底層存放區的 Stream。 + 1 + + + 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 + 在資料流的目前位置。 + 發生 I/O 錯誤。 + 資料流不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 + 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 + 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 + + 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 + 自目前資料流讀取的最大位元組數。 + + 和 的總和大於緩衝區的長度。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 + 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + + 方法必須擲回 。 + 2 + + + 在衍生類別中覆寫時，設定在目前資料流的位置。 + 目前資料流的新位置。 + 相對於 參數的位元組位移。 + + 類型的值，表示用來取得新位置的參考點。 + 發生 I/O 錯誤。 + 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 在衍生類別中覆寫時，設定目前資料流的長度。 + 想要的目前資料流長度 (單位為位元組)。 + 發生 I/O 錯誤。 + 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 + 位元組陣列。此方法會從 複製 位元組到目前資料流。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入目前資料流的位元組數目。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 資料流不支援寫入。 + + 流关闭后调用。 + 1 + + + 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 + 寫入資料流的位元組。 + 發生 I/O 錯誤。 + 資料流不支援寫入，或資料流已經關閉。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + + 方法必須擲回 。 + 2 + + + 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 為指定的資料流，初始化 類別的新執行個體。 + 要讀取的資料流。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + 最小緩衝區大小。 + 資料流不支援讀取。 + + 或 為 null。 + + 小於或等於零值。 + + + 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要讀取的資料流。 + 要使用的字元編碼。 + true 表示在檔案開頭尋找位元順序標記；否則為 false。 + 最小緩衝區大小。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + + 傳回基礎資料流。 + 基礎資料流。 + 2 + + + 取得目前 物件使用的目前字元編碼。 + 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 + 2 + + + 清除內部緩衝區。 + 2 + + + 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得表示現行資料流位置是否在資料流結尾的值。 + 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 + 已處置基礎資料流。 + 1 + + + 空資料流周圍的 物件。 + 1 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 1 + + + 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 + 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 + 發生 I/O 錯誤。 + 1 + + + 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 + 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + 要開始寫入的 的索引。 + 要讀取的字元數上限。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤，例如資料流已經關閉。 + 1 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前資料流讀取一行字元，並將資料以字串傳回。 + 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 + 下一行中的字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到資料流末端的所有字元。 + 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 + 字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 + 1 + + + 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + + 不可寫入。 + + 為 null。 + + + 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + + 或 是 null。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 + 強制 清除其緩衝區，則為 true，否則為 false。 + 1 + + + 取得以備份存放區作介面的基礎資料流。 + StreamWriter 正在寫入的資料流。 + 2 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + + + 取得寫入輸出的 。 + + (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 + 2 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 + 目前寫入器已關閉。 + 發生 I/O 錯誤。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + 1 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + 已處置資料流。 + + + 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將一個字元寫入資料流。 + 要寫入資料流的字元。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元陣列寫入資料流。 + 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元子陣列寫入資料流。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字串寫入資料流。 + 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入資料流。 + 表示非同步寫入作業的工作。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 將行結束字元以非同步方式寫入資料流。 + 表示非同步寫入作業的工作。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 實作讀取字串的 。 + 2 + + + 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 + + 應該初始化的目的字串。 + + 參數為 null。 + + + 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 + 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 + 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + 緩衝區中的起始索引。 + 要讀取的字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負數。 + 目前的讀取器已關閉。 + 2 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前字串讀取一行字元，並將資料以字串傳回。 + 目前字串的下一行，如果已到達字串的結尾，則為 null。 + 目前的讀取器已關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 2 + + + 自目前字串非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 基礎字串從目前位置至結尾的內容。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 目前的讀取器已關閉。 + 2 + + + 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 + 字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的控制項格式，初始化 類別的新執行個體。 + 控制格式的 物件。 + + + 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 + 要寫入至其中的 StringBuilder。 + + 為 null。 + + + 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 + 要寫入至其中的 StringBuilder。 + 控制格式的 物件。 + + 為 null。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得寫入輸出的 。 + 寫入輸出的 Encoding。 + 1 + + + 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + + + 傳回基礎 。 + 基礎 StringBuilder。 + 2 + + + 傳回字串，包含被寫入至目前 StringWriter 的字元。 + 字串，包含被寫入至目前 StringWriter 的字元。 + 2 + + + 將一個字元寫入至字串。 + 要寫入的字元。 + 寫入器關閉。 + 2 + + + 將字元子陣列寫入至字串。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 或 為負數。 + ( + )> 。Length. + 寫入器關閉。 + 2 + + + 將字串寫入至目前字串。 + 要寫入的字串。 + 寫入器關閉。 + 2 + + + 以非同步方式將字元寫入至字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入至字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入至目前字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 代表可以讀取一連串連續字元的讀取器 (Reader)。 + 2 + + + 初始化 類別的新執行個體。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 提供未讀取資料的 TextReader。 + 1 + + + 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 + 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 2 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自文字讀取器讀取一行字元，並將資料以字串傳回。 + 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 + 發生 I/O 錯誤。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + + 已經關閉。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 字串，包含從目前位置到文字讀取器結尾的所有字元。 + 發生 I/O 錯誤。 + + 已經關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 + 字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的格式提供者，初始化 類別的新執行個體。 + 控制格式設定的 物件。 + + + 儲存這個 TextWriter 所使用的新行字元。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 + 寫入輸出時使用的字元編碼。 + 1 + + + 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 文字寫入器已處置。 + 寫入器目前由先前寫入作業所使用。 + + + 取得控制格式設定的物件。 + 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 + 2 + + + 取得或設定目前 TextWriter 所使用的行結束字元字串。 + 目前 TextWriter 的行結束字元字串。 + 2 + + + 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將 Boolean 值的文字表示寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列寫入到文字字串或資料流。 + 要寫入到文字資料流的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元的子陣列寫入到文字字串或資料流。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 + 要寫入的物件。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串寫入到文字字串或資料流。 + 要寫入的字串。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + + 或 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 將行結束字元寫入到文字字串或資料流。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 中開始讀取資料的字元位置。 + 要寫入的最大字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的物件。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入的字串。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + 傳入的字串或物件為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將行結束字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.dll new file mode 100644 index 0000000000000000000000000000000000000000..ddd816f645b552c98870e5030da2448f0ee46325 GIT binary patch literal 30528 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 literal 0 HcmV?d00001 diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml new file mode 100644 index 00000000..94677abb --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Reads primitive data types as binary values in a specific encoding. + 2 + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The input stream. + The stream does not support reading, is null, or is already closed. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The input stream. + The character encoding to use. + The stream does not support reading, is null, or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The input stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support reading, is null, or is already closed. + + or is null. + + + Exposes access to the underlying stream of the . + The underlying stream associated with the BinaryReader. + 2 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Fills the internal buffer with the specified number of bytes read from the stream. + The number of bytes to be read. + The end of the stream is reached before could be read. + An I/O error occurs. + Requested is larger than the internal buffer size. + + + Returns the next available character and does not advance the byte or character position. + The next available character, or -1 if no more characters are available or the stream does not support seeking. + An I/O error occurs. + The current character cannot be decoded into the internal character buffer by using the selected for the stream. + 2 + + + Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + The next character from the input stream, or -1 if no characters are currently available. + An I/O error occurs. + The stream is closed. + 2 + + + Reads the specified number of bytes from the stream, starting from a specified point in the byte array. + The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of bytes to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of characters from the stream, starting from a specified point in the character array. + The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. + The buffer to read data into. + The starting point in the buffer at which to begin reading into the buffer. + The number of characters to read. + The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + + is null. + + or is negative. + The stream is closed. + An I/O error occurs. + 2 + + + Reads in a 32-bit integer in compressed format. + A 32-bit integer in compressed format. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + The stream is corrupted. + + + Reads a Boolean value from the current stream and advances the current position of the stream by one byte. + true if the byte is nonzero; otherwise, false. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the next byte from the current stream and advances the current position of the stream by one byte. + The next byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. + A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. + The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + An I/O error occurs. + The stream is closed. + + is negative. + 2 + + + Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. + A character read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + A surrogate character was read. + 2 + + + Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. + A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. + The number of characters to read. + The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. + The stream is closed. + An I/O error occurs. + + is negative. + 2 + + + Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. + A decimal value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. + An 8-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. + A 2-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. + A 4-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. + An 8-byte signed integer read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a signed byte from this stream and advances the current position of the stream by one byte. + A signed byte read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. + A 4-byte floating point value read from the current stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. + The string being read. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. + A 2-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. + A 4-byte unsigned integer read from this stream. + The end of the stream is reached. + The stream is closed. + An I/O error occurs. + 2 + + + Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. + An 8-byte unsigned integer read from this stream. + The end of the stream is reached. + An I/O error occurs. + The stream is closed. + 2 + + + Writes primitive types in binary to a stream and supports writing strings in a specific encoding. + 2 + + + Initializes a new instance of the class that writes to a stream. + + + Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. + The output stream. + The stream does not support writing or is already closed. + + is null. + + + Initializes a new instance of the class based on the specified stream and character encoding. + The output stream. + The character encoding to use. + The stream does not support writing or is already closed. + + or is null. + + + Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. + The output stream. + The character encoding to use. + true to leave the stream open after the object is disposed; otherwise, false. + The stream does not support writing or is already closed. + + or is null. + + + Gets the underlying stream of the . + The underlying stream associated with the BinaryWriter. + 1 + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Specifies a with no backing store. + 1 + + + Holds the underlying stream. + + + Sets the position within the current stream. + The position with the current stream. + A byte offset relative to . + A field of indicating the reference point from which the new position is to be obtained. + The file pointer was moved to an invalid location. + The value is invalid. + 1 + + + Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. + The Boolean value to write (0 or 1). + An I/O error occurs. + The stream is closed. + 1 + + + Writes an unsigned byte to the current stream and advances the stream position by one byte. + The unsigned byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a byte array to the underlying stream. + A byte array containing the data to write. + An I/O error occurs. + The stream is closed. + + is null. + 1 + + + Writes a region of a byte array to the current stream. + A byte array containing the data to write. + The starting point in at which to begin writing. + The number of bytes to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + The non-surrogate, Unicode character to write. + An I/O error occurs. + The stream is closed. + + is a single surrogate character. + 1 + + + Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. + A character array containing the data to write. + + is null. + The stream is closed. + An I/O error occurs. + 1 + + + Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. + A character array containing the data to write. + The starting point in from which to begin writing. + The number of characters to write. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a decimal value to the current stream and advances the stream position by sixteen bytes. + The decimal value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. + The eight-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. + The two-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. + The four-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. + The eight-byte signed integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a signed byte to the current stream and advances the stream position by one byte. + The signed byte to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. + The four-byte floating-point value to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. + The value to write. + An I/O error occurs. + + is null. + The stream is closed. + 1 + + + Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. + The two-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. + The four-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. + The eight-byte unsigned integer to write. + An I/O error occurs. + The stream is closed. + 1 + + + Writes a 32-bit integer in a compressed format. + The 32-bit integer to be written. + The end of the stream is reached. + The stream is closed. + The stream is closed. + + + The exception that is thrown when reading is attempted past the end of a stream. + 2 + + + Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. + + + Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + The exception that is thrown when a data stream is in an invalid format. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class with an expandable capacity initialized to zero. + + + Initializes a new non-resizable instance of the class based on the specified byte array. + The array of unsigned bytes from which to create the current stream. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. + The array of unsigned bytes from which to create this stream. + The setting of the property, which determines whether the stream supports writing. + + is null. + + + Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + + is null. + + or is less than zero. + The buffer length minus is less than . + + + Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. + The array of unsigned bytes from which to create this stream. + The index in at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + + is null. + + or are negative. + The buffer length minus is less than . + + + Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. + The array of unsigned bytes from which to create this stream. + The index into at which the stream begins. + The length of the stream in bytes. + The setting of the property, which determines whether the stream supports writing. + true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. + + is null. + + or is negative. + The buffer length minus is less than . + + + Initializes a new instance of the class with an expandable capacity initialized as specified. + The initial size of the internal array in bytes. + + is negative. + + + Gets a value indicating whether the current stream supports reading. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports seeking. + true if the stream is open. + 2 + + + Gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 2 + + + Gets or sets the number of bytes allocated for this stream. + The length of the usable portion of the buffer for the stream. + A capacity is set that is negative or less than the current length of the stream. + The current stream is closed. + set is invoked on a stream whose capacity cannot be modified. + 2 + + + Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. + The token to monitor for cancellation requests. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases the unmanaged resources used by the class and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Overrides the method so that no action is performed. + 2 + + + Asynchronously clears all buffers for this stream, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. + The stream has been disposed. + + + Gets the length of the stream in bytes. + The length of the stream in bytes. + The stream is closed. + 2 + + + Gets or sets the current position within the stream. + The current position within the stream. + The position is set to a negative value or a value greater than . + The stream is closed. + 2 + + + Reads a block of bytes from the current stream and writes the data to a buffer. + The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. + When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. + The zero-based byte offset in at which to begin storing data from the current stream. + The maximum number of bytes to read. + + is null. + + or is negative. + + subtracted from the buffer length is less than . + The current stream instance is closed. + 2 + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the current stream. + The byte cast to a , or -1 if the end of the stream has been reached. + The current stream instance is closed. + 2 + + + Sets the position within the current stream to the specified value. + The new position within the stream, calculated by combining the initial reference point and the offset. + The new position within the stream. This is relative to the parameter, and can be positive or negative. + A value of type , which acts as the seek reference point. + Seeking is attempted before the beginning of the stream. + + is greater than . + There is an invalid . -or- caused an arithmetic overflow. + The current stream instance is closed. + 2 + + + Sets the length of the current stream to the specified value. + The value at which to set the length. + The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. + + is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. + 2 + + + Writes the stream contents to a byte array, regardless of the property. + A new byte array. + 2 + + + Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. + true if the conversion was successful; otherwise, false. + The byte array segment from which this stream was created. + + + Writes a block of bytes to the current stream using data read from a buffer. + The buffer to write data from. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The maximum number of bytes to write. + + is null. + The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. + + subtracted from the buffer length is less than . + + or are negative. + An I/O error occurs. + The current stream instance is closed. + 2 + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current stream at the current position. + The byte to write. + The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. + The current stream is closed. + 2 + + + Writes the entire contents of this memory stream to another stream. + The stream to write this memory stream to. + + is null. + The current or target stream is closed. + 2 + + + Specifies the position in a stream to use for seeking. + 2 + + + Specifies the beginning of a stream. + + + Specifies the current position within a stream. + + + Specifies the end of a stream. + + + Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. + 2 + + + Initializes a new instance of the class. + + + When overridden in a derived class, gets a value indicating whether the current stream supports reading. + true if the stream supports reading; otherwise, false. + 1 + + + When overridden in a derived class, gets a value indicating whether the current stream supports seeking. + true if the stream supports seeking; otherwise, false. + 1 + + + Gets a value that determines whether the current stream can time out. + A value that determines whether the current stream can time out. + 2 + + + When overridden in a derived class, gets a value indicating whether the current stream supports writing. + true if the stream supports writing; otherwise, false. + 1 + + + Reads the bytes from the current stream and writes them to another stream. + The stream to which the contents of the current stream will be copied. + + is null. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + The stream to which the contents of the current stream will be copied. + The size of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + The current stream does not support reading.-or- does not support writing. + Either the current stream or were closed before the method was called. + An I/O error occurred. + + + Asynchronously reads the bytes from the current stream and writes them to another stream. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + + is null. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. + A task that represents the asynchronous copy operation. + The stream to which the contents of the current stream will be copied. + The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. + The token to monitor for cancellation requests. The default value is . + + is null. + + is negative or zero. + Either the current stream or the destination stream is disposed. + The current stream does not support reading, or the destination stream does not support writing. + + + Releases all resources used by the . + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. + An I/O error occurs. + 2 + + + Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. + A task that represents the asynchronous flush operation. + The token to monitor for cancellation requests. The default value is . + The stream has been disposed. + + + When overridden in a derived class, gets the length in bytes of the stream. + A long value representing the length of the stream in bytes. + A class derived from Stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + A Stream with no backing store. + 1 + + + When overridden in a derived class, gets or sets the position within the current stream. + The current position within the stream. + An I/O error occurs. + The stream does not support seeking. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. + An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. + The zero-based byte offset in at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The sum of and is larger than the buffer length. + + is null. + + or is negative. + An I/O error occurs. + The stream does not support reading. + Methods were called after the stream was closed. + 1 + + + Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + The buffer to write the data into. + The byte offset in at which to begin writing data from the stream. + The maximum number of bytes to read. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support reading. + The stream has been disposed. + The stream is currently in use by a previous read operation. + + + Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. + The unsigned byte cast to an Int32, or -1 if at the end of the stream. + The stream does not support reading. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. + A value, in miliseconds, that determines how long the stream will attempt to read before timing out. + The method always throws an . + 2 + + + When overridden in a derived class, sets the position within the current stream. + The new position within the current stream. + A byte offset relative to the parameter. + A value of type indicating the reference point used to obtain the new position. + An I/O error occurs. + The stream does not support seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 1 + + + When overridden in a derived class, sets the length of the current stream. + The desired length of the current stream in bytes. + An I/O error occurs. + The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. + Methods were called after the stream was closed. + 2 + + + When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + An array of bytes. This method copies bytes from to the current stream. + The zero-based byte offset in at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + The sum of  and  is greater than the buffer length. + + is null. + + or  is negative. + An I/O error occured, such as the specified file cannot be found. + The stream does not support writing. + + was called after the stream was closed. + 1 + + + Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. + A task that represents the asynchronous write operation. + The buffer to write data from. + The zero-based byte offset in from which to begin copying bytes to the stream. + The maximum number of bytes to write. + The token to monitor for cancellation requests. The default value is . + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream does not support writing. + The stream has been disposed. + The stream is currently in use by a previous write operation. + + + Writes a byte to the current position in the stream and advances the position within the stream by one byte. + The byte to write to the stream. + An I/O error occurs. + The stream does not support writing, or the stream is already closed. + Methods were called after the stream was closed. + 2 + + + Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. + A value, in miliseconds, that determines how long the stream will attempt to write before timing out. + The method always throws an . + 2 + + + Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream. + The stream to be read. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. + The stream to be read. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding. + The stream to be read. + The character encoding to use. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + + does not support reading. + + or is null. + + + Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. + The stream to be read. + The character encoding to use. + Indicates whether to look for byte order marks at the beginning of the file. + The minimum buffer size. + The stream does not support reading. + + or is null. + + is less than or equal to zero. + + + Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. + The stream to read. + The character encoding to use. + true to look for byte order marks at the beginning of the file; otherwise, false. + The minimum buffer size. + true to leave the stream open after the object is disposed; otherwise, false. + + + Returns the underlying stream. + The underlying stream. + 2 + + + Gets the current character encoding that the current object is using. + The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. + 2 + + + Clears the internal buffer. + 2 + + + Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets a value that indicates whether the current stream position is at the end of the stream. + true if the current stream position is at the end of the stream; otherwise false. + The underlying stream has been disposed. + 1 + + + A object around an empty stream. + 1 + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. + An I/O error occurs. + 1 + + + Reads the next character from the input stream and advances the character position by one character. + The next character from the input stream represented as an object, or -1 if no more characters are available. + An I/O error occurs. + 1 + + + Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. + The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The index of at which to begin writing. + The maximum number of characters to read. + The buffer length minus is less than . + + is null. + + or is negative. + An I/O error occurs, such as the stream is closed. + 1 + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurred. + + + Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current stream and returns the data as a string. + The next line from the input stream, or null if the end of the input stream is reached. + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads a line of characters asynchronously from the current stream and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the stream. + The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). + There is insufficient memory to allocate a buffer for the returned string. + An I/O error occurs. + 1 + + + Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. + The number of characters is larger than . + The stream has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. + 1 + + + Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. + The stream to write to. + + is not writable. + + is null. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. + The stream to write to. + The character encoding to use. + + or is null. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + + or is null. + + is negative. + + is not writable. + + + Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. + The stream to write to. + The character encoding to use. + The buffer size, in bytes. + true to leave the stream open after the object is disposed; otherwise, false. + + or is null. + + is negative. + + is not writable. + + + Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . + true to force to flush its buffer; otherwise, false. + 1 + + + Gets the underlying stream that interfaces with a backing store. + The stream this StreamWriter is writing to. + 2 + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + The current encoding does not support displaying half of a Unicode surrogate pair. + + + Gets the in which the output is written. + The specified in the constructor for the current instance, or if an encoding was not specified. + 2 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. + The current writer is closed. + An I/O error has occurred. + The current encoding does not support displaying half of a Unicode surrogate pair. + 1 + + + Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The stream has been disposed. + + + Provides a StreamWriter with no backing store that can be written to, but not read from. + 1 + + + Writes a character to the stream. + The character to write to the stream. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a character array to the stream. + A character array containing the data to write. If is null, nothing is written. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a subarray of characters to the stream. + A character array that contains the data to write. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The buffer length minus is less than . + + or is negative. + An I/O error occurs. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + 1 + + + Writes a string to the stream. + The string to write to the stream. If is null, nothing is written. + + is true or the buffer is full, and current writer is closed. + + is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. + An I/O error occurs. + 1 + + + Writes a character to the stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the stream asynchronously. + A task that represents the asynchronous write operation. + A character array that contains the data to write. + The character position in the buffer at which to begin reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string to the stream asynchronously. + A task that represents the asynchronous write operation. + The string to write to the stream. If is null, nothing is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character to write to the stream. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The stream writer is disposed. + The stream writer is currently in use by a previous write operation. + + + Implements a that reads from a string. + 2 + + + Initializes a new instance of the class that reads from the specified string. + The string to which the should be initialized. + The parameter is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Returns the next available character but does not consume it. + An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. + The current reader is closed. + 2 + + + Reads the next character from the input string and advances the character position by one character. + The next character from the underlying string, or -1 if no more characters are available. + The current reader is closed. + 2 + + + Reads a block of characters from the input string and advances the character position by . + The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The starting index in the buffer. + The number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The current reader is closed. + 2 + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the current string and returns the data as a string. + The next line from the current string, or null if the end of the string is reached. + The current reader is closed. + There is insufficient memory to allocate a buffer for the returned string. + 2 + + + Reads a line of characters asynchronously from the current string and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. + The number of characters in the next line is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the string and returns them as a single string. + The content from the current position to the end of the underlying string. + There is insufficient memory to allocate a buffer for the returned string. + The current reader is closed. + 2 + + + Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. + The number of characters is larger than . + The string reader has been disposed. + The reader is currently in use by a previous read operation. + + + Implements a for writing information to a string. The information is stored in an underlying . + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format control. + An object that controls formatting. + + + Initializes a new instance of the class that writes to the specified . + The StringBuilder to write to. + + is null. + + + Initializes a new instance of the class that writes to the specified and has the specified format provider. + The StringBuilder to write to. + An object that controls formatting. + + is null. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the in which the output is written. + The Encoding in which the output is written. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + + + Returns the underlying . + The underlying StringBuilder. + 2 + + + Returns a string containing the characters written to the current StringWriter so far. + The string containing the characters written to the current StringWriter. + 2 + + + Writes a character to the string. + The character to write. + The writer is closed. + 2 + + + Writes a subarray of characters to the string. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + + or is negative. + ( + )> . Length. + The writer is closed. + 2 + + + Writes a string to the current string. + The string to write. + The writer is closed. + 2 + + + Writes a character to the string asynchronously. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the string asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string to the current string asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character to write to the string. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the string. + A task that represents the asynchronous write operation. + The character array to write data from. + The position in the buffer at which to start reading data. + The maximum number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the current string. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The string writer is disposed. + The string writer is currently in use by a previous write operation. + + + Represents a reader that can read a sequential series of characters. + 2 + + + Initializes a new instance of the class. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Provides a TextReader with no data to read from. + 1 + + + Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. + An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. + The is closed. + An I/O error occurs. + 1 + + + Reads the next character from the text reader and advances the character position by one character. + The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. + The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. + When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. + + is null. + The buffer length minus is less than . + + or is negative. + The is closed. + An I/O error occurs. + 2 + + + Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. + A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. + When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. + The position in at which to begin writing. + The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. + + is null. + + or is negative. + The sum of and is larger than the buffer length. + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads a line of characters from the text reader and returns the data as a string. + The next line from the reader, or null if all characters have been read. + An I/O error occurs. + There is insufficient memory to allocate a buffer for the returned string. + The is closed. + The number of characters in the next line is larger than + 1 + + + Reads a line of characters asynchronously and returns the data as a string. + A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. + The number of characters in the next line is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Reads all characters from the current position to the end of the text reader and returns them as one string. + A string that contains all characters from the current position to the end of the text reader. + An I/O error occurs. + The is closed. + There is insufficient memory to allocate a buffer for the returned string. + The number of characters in the next line is larger than + 1 + + + Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. + A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. + The number of characters is larger than . + The text reader has been disposed. + The reader is currently in use by a previous read operation. + + + Represents a writer that can write a sequential series of characters. This class is abstract. + 2 + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with the specified format provider. + An object that controls formatting. + + + Stores the newline characters used for this TextWriter. + + + Releases all resources used by the object. + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + When overridden in a derived class, returns the character encoding in which the output is written. + The character encoding in which the output is written. + 1 + + + Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + 1 + + + Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. + A task that represents the asynchronous flush operation. + The text writer is disposed. + The writer is currently in use by a previous write operation. + + + Gets an object that controls formatting. + An object for a specific culture, or the formatting of the current culture if no other culture is specified. + 2 + + + Gets or sets the line terminator string used by the current TextWriter. + The line terminator string for the current TextWriter. + 2 + + + Provides a TextWriter with no backing store that can be written to, but not read from. + 1 + + + Writes the text representation of a Boolean value to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a character array to the text string or stream. + The character array to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters to the text string or stream. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte floating-point value to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object to the text string or stream by calling the ToString method on that object. + The object to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string to the text string or stream. + The string to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes a formatted string to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + + or is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character array to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If is null, nothing is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string to the text string or stream asynchronously. + A task that represents the asynchronous write operation. + The string to write. If is null, nothing is written to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a line terminator to the text string or stream. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. + The Boolean value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a character followed by a line terminator to the text string or stream. + The character to write to the text stream. + The is closed. + An I/O error occurs. + 1 + + + Writes an array of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The is closed. + An I/O error occurs. + 1 + + + Writes a subarray of characters followed by a line terminator to the text string or stream. + The character array from which data is read. + The character position in at which to start reading data. + The maximum number of characters to write. + The buffer length minus is less than . + The parameter is null. + + or is negative. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a decimal value followed by a line terminator to the text string or stream. + The decimal value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. + The 8-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. + The 4-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. + The 8-byte signed integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. + The object to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. + The 4-byte floating-point value to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a string followed by a line terminator to the text string or stream. + The string to write. If is null, only the line terminator is written. + The is closed. + An I/O error occurs. + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). + 1 + + + Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + The first object to format and write. + The second object to format and write. + The third object to format and write. + + is null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). + 1 + + + Writes out a formatted string and a new line, using the same semantics as . + A composite format string (see Remarks). + An object array that contains zero or more objects to format and write. + A string or object is passed in as null. + The is closed. + An I/O error occurs. + + is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. + 1 + + + Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. + The 4-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. + The 8-byte unsigned integer to write. + The is closed. + An I/O error occurs. + 1 + + + Writes a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a character followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character to write to the text stream. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes an array of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write to the text stream. If the character array is null, only the line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The character array to write data from. + The character position in the buffer at which to start retrieving data. + The number of characters to write. + + is null. + The plus is greater than the buffer length. + + or is negative. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + Writes a string followed by a line terminator asynchronously to the text string or stream. + A task that represents the asynchronous write operation. + The string to write. If the value is null, only a line terminator is written. + The text writer is disposed. + The text writer is currently in use by a previous write operation. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml new file mode 100644 index 00000000..07b2661f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml @@ -0,0 +1,2151 @@ + + + + System.IO + + + + Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. + 2 + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. + Der Eingabestream. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + + Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Eingabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. + + oder ist null. + + + Gewährt Zugriff auf den zugrunde liegenden Stream von . + Der BinaryReader zugeordnete, zugrunde liegende Stream. + 2 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. + Die Anzahl der zu lesenden Bytes. + Das Ende des Streams ist erreicht, bevor gelesen werden konnte. + E/A-Fehler. + Die angeforderten überschreiten die interne Puffergröße. + + + Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. + Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. + 2 + + + Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. + Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Bytes. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. + Der Puffer, in den Daten gelesen werden sollen. + Der Anfangspunkt für das Lesen in den Puffer. + Die Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + + ist null. + + oder ist negativ. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 32-Bit-Ganzzahl in komprimiertem Format. + Eine 32-Bit-Ganzzahl in komprimiertem Format. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Der Datenstrom ist beschädigt. + + + Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + true, wenn das Byte ungleich 0 (null) ist, andernfalls false. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. + Das nächste aus dem aktuellen Stream gelesene Byte. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. + Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + E/A-Fehler. + Der Stream ist geschlossen. + + ist negativ. + 2 + + + Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein aus dem aktuellen Stream gelesenes Zeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + Ein Ersatzzeichenzeichen wurde gelesen. + 2 + + + Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. + Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. + Die Anzahl der zu lesenden Zeichen. + Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. + Der Stream ist geschlossen. + E/A-Fehler. + + ist negativ. + 2 + + + Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. + Ein aus dem aktuellen Stream gelesener Dezimalwert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. + Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. + Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. + Die gelesene Zeichenfolge. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. + Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. + Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + E/A-Fehler. + 2 + + + Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. + Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. + Das Ende des Streams ist erreicht. + E/A-Fehler. + Der Stream ist geschlossen. + 2 + + + Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. + 2 + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. + + + Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. + Der Ausgabestream. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + ist null. + + + Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. + Der Ausgabestream. + Die zu verwendende Zeichencodierung. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + + oder ist null. + + + Ruft den zugrunde liegenden Stream von ab. + Der BinaryWriter zugeordnete, zugrunde liegende Stream. + 1 + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Gibt eine -Klasse ohne Sicherungsspeicher an. + 1 + + + Enthält den zugrunde liegenden Stream. + + + Legt die Position im aktuellen Stream fest. + Die Position im aktuellen Stream. + Ein Byteoffset im Verhältnis zu . + Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. + Der Dateizeiger wurde an eine ungültige Position verschoben. + Der -Wert ist ungültig. + 1 + + + Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. + Der zu schreibende Boolean-Wert (0 (null) oder 1). + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Bytearray in den zugrunde liegenden Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + E/A-Fehler. + Der Stream ist geschlossen. + + ist null. + 1 + + + Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. + Ein Bytearray, das die zu schreibenden Daten enthält. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Bytes. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). + E/A-Fehler. + Der Stream ist geschlossen. + + ist ein einzelnes Ersatzzeichen. + 1 + + + Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + + ist null. + Der Stream ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. + Ein Zeichenarray mit den zu schreibenden Daten. + Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. + Der zu schreibende Dezimalwert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Der zu schreibende 8-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das zu schreibende Byte mit Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Der zu schreibende 4-Byte-Gleitkommawert. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. + Der zu schreibende Wert. + E/A-Fehler. + + ist null. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. + Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + E/A-Fehler. + Der Stream ist geschlossen. + 1 + + + Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. + Die zu schreibende 32-Bit-Ganzzahl. + Das Ende des Streams ist erreicht. + Der Stream ist geschlossen. + Der Stream ist geschlossen. + + + Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. + 2 + + + Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. + + + Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. + + ist null. + + + Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + + Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + + ist null. + + oder ist kleiner als 0. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , bei dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. + Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. + Der Index in , an dem der Stream beginnt. + Die Länge des Streams in Bytes. + Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. + true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. + + ist null. + + oder ist negativ. + Die Länge des Puffers minus ist kleiner als . + + + Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. + Die Anfangsgröße des internen Arrays in Bytes. + + ist negativ. + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream geöffnet ist. + 2 + + + Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 2 + + + Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. + Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. + Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. + Der aktuelle Stream ist geschlossen. + set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. + 2 + + + Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. + Das Token zum überwachen von Abbruchanforderungen . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen . + Der Stream wurde freigegeben. + + + Ruft die Länge des Streams in Bytes ab. + Die Länge des Streams in Bytes. + Der Stream ist geschlossen. + 2 + + + Ruft die aktuelle Position im Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. + Der Stream ist geschlossen. + 2 + + + Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. + Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. + Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + + subtrahiert von der Pufferlänge ist kleiner als . + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem aktuellen Stream. + Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Position im aktuellen Stream auf den angegebenen Wert fest. + Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. + Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. + Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. + Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. + + ist größer als . + Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. + Der Wert, auf den die Länge festgelegt werden soll. + Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. + + ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. + 2 + + + Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. + Ein neues Bytearray. + 2 + + + Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. + true, wenn die Konvertierung erfolgreich war, andernfalls false. + Das Bytearraysegment, aus dem der Stream erstellt wurde. + + + Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. + + subtrahiert von der Pufferlänge ist kleiner als . + + oder ist negativ. + E/A-Fehler. + Der aktuelle Instanz des Streams ist geschlossen. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuelle Position im aktuellen Stream. + Das zu schreibende Byte. + Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. + Der aktuelle Stream ist geschlossen. + 2 + + + Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. + Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. + + ist null. + Der aktuelle Stream oder der Zielstream ist geschlossen. + 2 + + + Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. + 2 + + + Gibt den Anfang eines Streams an. + + + Gibt die aktuelle Position innerhalb eines Streams an. + + + Gibt das Ende eines Streams an. + + + Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. + true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. + true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. + 1 + + + Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. + 2 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. + true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. + 1 + + + Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. + Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. + Ein E/A-Fehler ist aufgetreten. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + + ist null. + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. + Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. + Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. + Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + ist negativ oder 0 (null). + Entweder der aktuelle Stream oder der Zielstream wird freigegeben. + Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. + + + Gibt alle vom verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + E/A-Fehler. + 2 + + + Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + Der Stream wurde freigegeben. + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. + Ein Long-Wert, der die Länge des Streams in Bytes darstellt. + Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Ein Stream ohne Sicherungsspeicher. + 1 + + + Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. + Die aktuelle Position innerhalb des Streams. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. + Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. + Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. + Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. + Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. + Die Summe aus und ist größer als die Pufferlänge. + + ist null. + + oder ist negativ. + E/A-Fehler. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Der Puffer, in den die Daten geschrieben werden sollen. + Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. + Die maximale Anzahl der zu lesenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Lesevorgänge werden vom Stream nicht unterstützt. + Der Stream wurde freigegeben. + Der Stream wird gerade durch einen früheren Lesevorgang. + + + Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. + Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. + Lesevorgänge werden vom Stream nicht unterstützt. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. + Die neue Position innerhalb des aktuellen Streams. + Ein Byteoffset relativ zum -Parameter. + Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. + E/A-Fehler. + Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. + Die gewünschte Länge des aktuellen Streams in Bytes. + E/A-Fehler. + Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. + Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. + Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. + Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. + Die Summe der  und  ist größer als die Länge des Puffers. + + ist null. + + oder  ist negativ. + E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. + Der Stream unterstützt das Schreiben nicht. + + wurde aufgerufen, nachdem der Stream geschlossen wurde. + 1 + + + Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Puffer, aus dem Daten geschrieben werden sollen. + Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. + Die maximale Anzahl der zu schreibenden Bytes. + Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream unterstützt das Schreiben nicht. + Der Stream wurde freigegeben. + Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. + Das Byte, das in den Stream geschrieben werden soll. + E/A-Fehler. + Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. + Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. + 2 + + + Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. + Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. + Die -Methode löst immer eine aus. + 2 + + + Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. + Der zu lesende Stream. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + + unterstützt keine Lesevorgänge. + + oder ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. + Die Mindestgröße des Puffers. + Lesevorgänge werden vom Stream nicht unterstützt. + + oder ist null. + + ist kleiner oder gleich 0 (null). + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. + Der zu lesende Stream. + Die zu verwendende Zeichencodierung. + true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. + Die Mindestgröße des Puffers. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + + Gibt den zugrunde liegenden Stream zurück. + Der zugrunde liegende Stream. + 2 + + + Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. + Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. + 2 + + + Löscht den internen Puffer. + 2 + + + Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. + true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. + Der zugrunde liegende Stream wurde verworfen. + 1 + + + Ein -Objekt um einen leeren Stream. + 1 + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. + E/A-Fehler. + 1 + + + Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. + Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Index von , bei dem mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + + ist null. + + oder ist negativ. + Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + Ein E/A-Fehler ist aufgetreten. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. + Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + E/A-Fehler. + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. + Die Anzahl der Zeichen ist niedriger als . + Der Stream wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. + 1 + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + + ist schreibgeschützt. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + + oder ist null. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. + Der Stream, in den geschrieben werden soll. + Die zu verwendende Zeichencodierung. + Die Puffergröße in Byte. + true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. + + oder ist null. + + ist negativ. + + ist schreibgeschützt. + + + Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. + true, um zum Entleeren des Puffers zu zwingen, andernfalls false. + 1 + + + Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. + Der Stream, in den dieser StreamWriter schreibt. + 2 + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. + 2 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. + Der aktuelle Writer wird geschlossen. + Ein E/A-Fehler ist aufgetreten. + Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. + 1 + + + Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Stream wurde freigegeben. + + + Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt ein Zeichen in den Stream. + Das in den Stream zu schreibende Zeichen. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Zeichenarray in den Stream. + Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt ein Teilarray von Zeichen in den Stream. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + E/A-Fehler. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + 1 + + + Schreibt eine Zeichenfolge in den Stream. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. + + ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. + + ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Ein Zeichenarray, das die zu schreibenden Daten enthält. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Stream zu schreibende Zeichen. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Streamwriter wird freigegeben. + Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Implementiert einen , der aus einer Zeichenfolge liest. + 2 + + + Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. + Die Zeichenfolge, mit der der initialisiert werden soll. + Der -Parameter ist null. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. + Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. + Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Der Anfangsindex im Puffer. + Die Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. + Der aktuelle Reader ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + 2 + + + Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der aktuelle Reader ist geschlossen. + 2 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. + Die Anzahl der Zeichen ist niedriger als . + Der Zeichenfolgen-Reader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. + Ein -Objekt zum Steuern der Formatierung. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . + Der StringBuilder, in den geschrieben werden soll. + + ist null. + + + Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. + Der StringBuilder, in den geschrieben werden soll. + Ein -Objekt zum Steuern der Formatierung. + + ist null. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Ruft die ab, in der die Ausgabe geschrieben wird. + Die Encoding, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + + + Gibt den zugrunde liegenden zurück. + Der zugrunde liegende StringBuilder. + 2 + + + Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. + 2 + + + Schreibt ein Zeichen in die Zeichenfolge. + Das zu schreibende Zeichen. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Teilarray von Zeichen in die Zeichenfolge. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + + oder ist negativ. + ( + )> .Length. + Der Writer ist geschlossen. + 2 + + + Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. + Die zu schreibende Zeichenfolge. + Der Writer ist geschlossen. + 2 + + + Schreibt ein Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in die Zeichenfolge zu schreibende Zeichen. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Zeichenfolgenwriter wird freigegeben. + Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Stellt einen TextReader ohne zu lesende Daten bereit. + 1 + + + Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. + Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. + Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. + Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen. + + ist null. + Die Länge des Puffers minus ist kleiner als . + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 2 + + + Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. + Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. + Die Position in , an der mit dem Schreiben begonnen wird. + Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. + + ist null. + + oder ist negativ. + Die Summe aus und ist größer als die Pufferlänge. + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. + Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. + E/A-Fehler. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Der ist geschlossen. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. + E/A-Fehler. + Der ist geschlossen. + Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. + Die Anzahl der Zeichen in der nächsten Zeile ist größer als . + 1 + + + Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. + Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. + Die Anzahl der Zeichen ist niedriger als . + Der Textreader wurde freigegeben. + Der Reader wird gerade durch einen früheren Lesevorgang verwendet. + + + Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. + 2 + + + Initialisiert eine neue Instanz der -Klasse. + + + Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. + Ein -Objekt zum Steuern der Formatierung. + + + Speichert die für diesen TextWriter verwendeten Zeilenendemarken. + + + Gibt alle vom -Objekt verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. + Die Zeichencodierung, in der die Ausgabe geschrieben wird. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + 1 + + + Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. + Eine Aufgabe, die die asynchrone Leerung darstellt. + Der Textwriter wird freigegeben. + Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Ruft ein Objekt zum Steuern der Formatierung ab. + Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. + 2 + + + Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. + Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. + 2 + + + Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichenarray. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. + Das zu schreibende Objekt. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + + oder ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Boolean-Wert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das in den Textstream zu schreibende Zeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das Zeichenarray, aus dem die Daten gelesen werden. + Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. + Die maximale Anzahl der zu schreibenden Zeichen. + Die Länge des Puffers minus ist kleiner als . + Der -Parameter ist null. + + oder ist negativ. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Der zu schreibende Dezimalwert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 8-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. + Der zu schreibende 4-Byte-Gleitkommawert. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Das erste zu formatierende und zu schreibende Objekt. + Das zweite zu formatierende und zu schreibende Objekt. + Das dritte zu formatierende und zu schreibende Objekt. + + ist null. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). + 1 + + + Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . + Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). + Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. + Eine Zeichenfolge oder ein Objekt wird als null übergeben. + Der ist geschlossen. + E/A-Fehler. + + ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. + 1 + + + Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. + Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. + Der ist geschlossen. + E/A-Fehler. + 1 + + + Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichen. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Das Zeichenarray, aus dem Daten geschrieben werden sollen. + Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. + Die Anzahl der zu schreibenden Zeichen. + + ist null. + Der und ist größer als die Pufferlänge. + + oder ist negativ. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. + Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. + Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. + Der Textwriter wird freigegeben. + Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml new file mode 100644 index 00000000..0b2c206b --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml @@ -0,0 +1,2090 @@ + + + + System.IO + + + + Lee tipos de datos primitivos como valores binarios en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. + La secuencia de entrada. + La secuencia no admite la lectura, es null, o ya está cerrada. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. + La secuencia de entrada. + Codificación de caracteres que se utilizará. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + La secuencia no admite la lectura, es null, o ya está cerrada. + El valor de o es null. + + + Expone el acceso a la secuencia subyacente de . + Secuencia subyacente asociada a BinaryReader. + 2 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. + Número de bytes que se va a leer. + Se llega al final de la secuencia antes de se ha podido leer. + Se produce un error de E/S. + Solicitado es mayor que el tamaño del búfer interno. + + + Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. + Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. + 2 + + + Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. + Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. + Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de bytes que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. + Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. + Búfer en el que se leen los datos. + Punto inicial del búfer en el que comienza la lectura. + Número de caracteres que se va a leer. + La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + El valor de es null. + + o es negativo. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero de 32 bits en formato comprimido. + Entero de 32 bits en formato comprimido. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + La secuencia está dañada. + + + Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Es true si el byte es distinto de cero; en caso contrario, es false. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. + Siguiente byte que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. + Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. + Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + Se produce un error de E/S. + La secuencia está cerrada. + + es negativo. + 2 + + + Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. + Carácter que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + Se ha leído un carácter suplente. + 2 + + + Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. + Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. + Número de caracteres que se va a leer. + El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. + La secuencia está cerrada. + Se produce un error de E/S. + + es negativo. + 2 + + + Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. + Valor decimal que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. + Valor de punto flotante de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. + Entero con signo de 2 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Entero con signo de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. + Entero con signo de 8 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. + Byte con signo que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. + Valor de punto flotante de 4 bytes que se lee en la secuencia actual. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. + Cadena que se lee. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. + Entero sin signo de 2 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. + Entero sin signo de 4 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + La secuencia está cerrada. + Se produce un error de E/S. + 2 + + + Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. + Entero sin signo de 8 bytes que se lee en esta secuencia. + Se llega al final de la secuencia. + Se produce un error de E/S. + La secuencia está cerrada. + 2 + + + Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. + 2 + + + Inicializa una nueva instancia de la clase que escribe en una secuencia. + + + Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. + Flujo de salida. + La secuencia no admite escritura o ya se encuentra cerrada. + + es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. + Flujo de salida. + Codificación de caracteres que se utilizará. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. + Flujo de salida. + Codificación de caracteres que se utilizará. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + La secuencia no admite escritura o ya se encuentra cerrada. + El valor de o de es null. + + + Obtiene la secuencia subyacente del objeto . + Flujo subyacente asociado a BinaryWriter. + 1 + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Especifica un objeto sin memoria auxiliar. + 1 + + + Contiene la secuencia subyacente. + + + Establece la posición en la secuencia actual. + Posición con la secuencia actual. + Desplazamiento de bytes relacionado con . + Un campo de que indica el punto de referencia del que se obtiene la nueva posición. + El puntero de archivo se ha movido a una posición no válida. + El valor de no es válido. + 1 + + + Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. + Valor Boolean que se va a escribir (0 ó 1). + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte sin signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una matriz de bytes en la secuencia subyacente. + Matriz de bytes que contiene los datos que se van a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es null. + 1 + + + Escribe una región de una matriz de bytes en la secuencia actual. + Matriz de bytes que contiene los datos que se van a escribir. + Punto inicial de donde comenzará la escritura. + Número de bytes que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. + El carácter Unicode no suplente que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + + es un carácter suplente único. + 1 + + + Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + + es null. + La secuencia está cerrada. + Se produce un error de E/S. + 1 + + + Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Punto inicial de donde se empieza a leer. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + + es null. + + o son negativos. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. + Valor decimal que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Valor de punto flotante de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero con signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero con signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero con signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. + Byte con signo que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Valor de punto flotante de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. + Valor que se va a escribir. + Se produce un error de E/S. + + es null. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. + Entero sin signo de dos bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. + Entero sin signo de cuatro bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. + Entero sin signo de ocho bytes que se va a escribir. + Se produce un error de E/S. + La secuencia está cerrada. + 1 + + + Escribe un entero de 32 bits en formato comprimido. + Entero de 32 bits que se va a escribir. + Se llega al final de la secuencia. + La secuencia está cerrada. + La secuencia está cerrada. + + + Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. + 2 + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. + + + Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Excepción que se inicia cuando el formato de un flujo de datos no es válido. + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. + + + Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. + Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + + Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + El valor de es null. + + o es menor que cero. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + El valor de es null. + + o son negativos. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. + Matriz de bytes sin signo a partir de la cual se crea esta secuencia. + Índice en en el que empieza la secuencia. + Longitud de la secuencia en bytes. + Establecimiento de la propiedad , que determina si la secuencia admite escritura. + Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. + El valor de es null. + + o es negativo. + La longitud del búfer menos es menor que . + + + Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. + Tamaño inicial de la matriz interna en bytes. + + es negativo. + + + Obtiene un valor que indica si la secuencia actual admite lectura. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite búsquedas. + true si el flujo está abierto. + 2 + + + Obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 2 + + + Obtiene o establece el número de bytes asignados a esta secuencia. + Longitud de la parte utilizable del búfer para la secuencia. + Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. + La secuencia actual está cerrada. + set se invoca en una secuencia cuya capacidad no se puede modificar. + 2 + + + Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero. + Token para supervisar solicitudes de cancelación. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Reemplaza el método de modo que no se realice ninguna acción. + 2 + + + De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación. + Se ha eliminado la secuencia. + + + Obtiene la longitud de la secuencia en bytes. + Longitud de la secuencia en bytes. + La secuencia está cerrada. + 2 + + + Obtiene o establece la posición actual dentro de la secuencia. + Posición actual dentro de la secuencia. + La posición se establece en un valor negativo o un valor mayor que . + La secuencia está cerrada. + 2 + + + Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. + Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. + Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. + Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + + resta de la longitud del búfer es menor que . + La instancia de la secuencia actual está cerrada. + 2 + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia actual. + El byte convertido en un o -1 si se llega al final de la secuencia. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la posición dentro de la secuencia actual en el valor especificado. + Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. + Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. + Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. + Se ha intentado realizar una búsqueda antes del inicio de la secuencia. + + es mayor que . + Hay un no válido . o bien se produjo un desbordamiento aritmético. + La instancia de la secuencia actual está cerrada. + 2 + + + Establece la longitud de la secuencia actual en el valor especificado. + Valor en el que establecer la longitud. + La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. + + es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. + 2 + + + Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . + Nueva matriz de bytes. + 2 + + + Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. + Es true si la conversión se realiza correctamente; en caso contrario, es false. + El segmento de matriz de bytes desde el que se creó esta secuencia. + + + Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número máximo de bytes que se pueden escribir. + El valor de es null. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. + + resta de la longitud del búfer es menor que . + + o son negativos. + Se produce un error de E/S. + La instancia de la secuencia actual está cerrada. + 2 + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte en la posición actual de la secuencia actual. + Byte que se va a escribir. + La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. + La secuencia actual está cerrada. + 2 + + + Escribe el contenido completo de esta secuencia de memoria en otra secuencia. + Secuencia en la que se va a escribir esta secuencia de memoria. + El valor de es null. + La secuencia actual o de destino está cerrada. + 2 + + + Especifica la posición usada para buscar en una secuencia. + 2 + + + Especifica el comienzo de una secuencia. + + + Especifica lo posición actual dentro de la secuencia. + + + Especifica el final de una secuencia. + + + Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 2 + + + Inicializa una nueva instancia de la clase . + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. + true si la secuencia admite lectura; en caso contrario, false. + 1 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. + true si la secuencia admite búsquedas; en caso contrario, false. + 1 + + + Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. + 2 + + + Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. + true si el flujo admite escritura; en caso contrario, false. + 1 + + + Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + La secuencia actual no admite lectura.o bien no se admite la escritura. + La secuencia de actual o se cerraron antes de la se llamó al método. + Error de E/S. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + El valor de es null. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. + Tarea que representa la operación de copia asincrónica. + Secuencia en la que se copiará el contenido de la secuencia actual. + Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + es un valor negativo o es cero. + Se desecha la secuencia actual o la secuencia de destino. + La secuencia actual no admite lectura o la secuencia de destino no admite escritura. + + + Libera todos los recursos usados por . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Se produce un error de E/S. + 2 + + + Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. + Tarea que representa la operación de vaciado asincrónico. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + Se ha eliminado la secuencia. + + + Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. + Un valor Long que representa la longitud de la secuencia en bytes. + Una clase derivada de Stream no admite la búsqueda. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Stream sin memoria auxiliar. + 1 + + + Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. + Posición actual dentro de la secuencia. + Se produce un error de E/S. + La secuencia no admite búsquedas. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. + Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. + Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. + Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. + Número máximo de bytes que se deben leer de la secuencia actual. + La suma de y es mayor que la longitud del búfer. + El valor de es null. + + o es negativo. + Se produce un error de E/S. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Búfer en el que se escriben los datos. + Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. + Número máximo de bytes que se pueden leer. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no admite lectura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de lectura anterior. + + + Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. + Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. + La secuencia no admite lectura. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. + La nueva posición dentro de la secuencia actual. + Desplazamiento de bytes relacionado con el parámetro . + Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. + Se produce un error de E/S. + La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 1 + + + Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. + Longitud deseada de la secuencia actual, en bytes. + Se produce un error de E/S. + La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. + Matriz de bytes.Este método copia bytes desde al flujo actual. + Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. + Número de bytes que se deben escribir en la secuencia actual. + La suma de  y  es mayor que la longitud del búfer. + + es null. + + o  es negativo. + Se produjo un error de E/S, como no se puede encontrar el archivo especificado. + La secuencia no es compatible con la escritura. + + se llama después de cerrar la secuencia. + 1 + + + Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. + Tarea que representa la operación de escritura asincrónica. + Búfer del que se van a escribir datos. + Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. + Número máximo de bytes que se pueden escribir. + Token para supervisar solicitudes de cancelación.El valor predeterminado es . + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + La secuencia no es compatible con la escritura. + Se ha eliminado la secuencia. + La secuencia está actualmente en uso por una operación de escritura anterior. + + + Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. + Byte que se debe escribir en la secuencia. + Se produce un error de E/S. + La secuencia no admite escritura o ya se encuentra cerrada. + Tras cerrar la secuencia, se llamó a algún método. + 2 + + + Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. + El método siempre produce una . + 2 + + + Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. + 1 + + + Inicializa una nueva instancia de la clase para el flujo especificado. + Secuencia que se va a leer. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de es null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + + no se admite la lectura. + El valor de o es null. + + + Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Indica si se deben buscar marcas de orden de byte al comienzo del archivo. + Tamaño mínimo de búfer. + La secuencia no admite lectura. + El valor de o es null. + + es menor o igual que cero. + + + Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. + Secuencia que se va a leer. + Codificación de caracteres que se utilizará. + Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. + Tamaño mínimo de búfer. + true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. + + + Devuelve la secuencia subyacente. + Secuencia subyacente. + 2 + + + Obtiene la codificación de caracteres que actualmente utiliza este objeto . + Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . + 2 + + + Borra el búfer interno. + 2 + + + Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene un valor que indica si la actual posición está al final de la secuencia. + Es true si la actual posición está al final de la secuencia; en caso contrario, es false. + Se ha eliminado la secuencia subyacente. + 1 + + + Objeto en torno a una secuencia vacía. + 1 + + + Devuelve el siguiente carácter disponible pero no lo consume. + Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. + El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. + Se produce un error de E/S. + 1 + + + Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. + Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Índice de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + La longitud del búfer menos es menor que . + El valor de es null. + + o es negativo. + Se produce un error de E/S, como el cierre de la secuencia. + 1 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. + El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + + o es negativo. + El se cierra. + Error de E/S. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + + o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. + El número de caracteres en la siguiente línea es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la secuencia. + Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + Se produce un error de E/S. + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. + El número de caracteres es mayor que . + Se ha eliminado la secuencia. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. + 1 + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + No se puede escribir en . + + is null. + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + + o es null. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. + Secuencia en la que se va a escribir. + Codificación de caracteres que se utilizará. + Tamaño del búfer en bytes. + true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. + + o es null. + El valor de es negativo. + No se puede escribir en . + + + Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . + Es true para que vacíe su búfer; en caso contrario, es false. + 1 + + + Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. + Secuencia en la que escribe este StreamWriter. + 2 + + + Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. + truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + + + Obtiene el donde se escribe el resultado. + + especificado en el constructor para la instancia actual o si no se ha especificado una codificación. + 2 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. + El sistema de escritura actual está cerrado. + Se produjo un error de E/S. + La codificación actual no admite que se muestre la mitad de un par suplente Unicode. + 1 + + + Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se ha eliminado la secuencia. + + + Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe un carácter en la secuencia. + Carácter que se va a escribir en la secuencia. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una matriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una submatriz de caracteres en la secuencia. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + Se produce un error de E/S. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + 1 + + + Escribe una cadena en la secuencia. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + + es true o el búfer está lleno, y el sistema de escritura actual está cerrado. + + es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que contiene los datos que se van a escribir. + Posición del carácter en el búfer donde comienza la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la lectura de datos. + Número máximo de caracteres que se van a escribir. + + is null. + La suma de y es mayor que la longitud del búfer. + El valor de o es negativo. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de secuencias. + El escritor de secuencias está actualmente en uso por una operación de escritura anterior. + + + Implementa que lee en una cadena. + 2 + + + Inicializa una nueva instancia de la clase que lee en la cadena especificada. + Cadena en la que debe inicializarse. + El parámetro es null. + + + Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Devuelve el siguiente carácter disponible pero no lo consume. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. + El sistema de lectura actual está cerrado. + 2 + + + Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. + Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. + El sistema de lectura actual está cerrado. + 2 + + + Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . + Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Índice inicial del búfer. + Número de caracteres que se va a leer. + + es null. + La longitud del búfer menos es menor que . + + o son negativos. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + + es null. + + o son negativos. + La suma de y es mayor que la longitud del búfer. + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. + El sistema de lectura actual está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + 2 + + + Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Contenido desde la posición actual hasta el final de la cadena subyacente. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El sistema de lectura actual está cerrado. + 2 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. + El número de caracteres es mayor que . + El lector de cadenas se ha desechado. + El lector está actualmente en uso por una operación de lectura anterior. + + + Implementa para escribir información en una cadena.La información se almacena en el subyacente. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Inicializa una nueva instancia de la clase que escribe en el especificado. + Objeto StringBuilder en el que se va a escribir. + + es null. + + + Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. + Objeto StringBuilder en el que se va a escribir. + Objeto que controla las operaciones de formato. + + es null. + + + Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Obtiene el donde se escribe el resultado. + Encoding donde se escribe el resultado. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + + + Devuelve el subyacente. + Objeto StringBuilder subyacente. + 2 + + + Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. + Cadena que contiene los caracteres escritos en el StringWriter actual. + 2 + + + Escribe un carácter en la cadena. + Carácter que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe una submatriz de caracteres en la cadena. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + + o son negativos. + ( + ) > .Length. + El sistema de escritura está cerrado. + 2 + + + Escribe una cadena en la cadena actual. + Cadena que se va a escribir. + El sistema de escritura está cerrado. + 2 + + + Escribe un carácter en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena actual de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. + Tarea que representa la operación de escritura asincrónico. + Carácter que se va a escribir en la cadena. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. + Tarea que representa la operación de escritura asincrónico. + Matriz de caracteres de la que se escriben los datos. + La posición en el búfer en el que se va a empezar a leer datos. + Número máximo de caracteres que se van a escribir. + + es null. + La suma de y es mayor que la longitud del búfer. + + o son negativos. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. + Tarea que representa la operación de escritura asincrónico. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de cadenas. + El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. + + + Representa un lector que puede leer una serie secuencial de caracteres. + 2 + + + Inicializa una nueva instancia de la clase . + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. + + + Proporciona un TextReader sin datos del que leer. + 1 + + + Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. + Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. + Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 1 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. + Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. + Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer. + El valor de es null. + La longitud del búfer menos es menor que . + El valor de o es negativo. + El objeto está cerrado. + Se produce un error de E/S. + 2 + + + Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. + Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. + Lugar de en el que comenzará la escritura. + Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. + El valor de es null. + El valor de o es negativo. + La suma de y es mayor que la longitud del búfer. + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. + Línea siguiente del lector o null si se han leído todos los caracteres. + Se produce un error de E/S. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El objeto está cerrado. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. + El número de caracteres de la siguiente línea es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. + Se produce un error de E/S. + El objeto está cerrado. + No hay memoria suficiente como para asignar un búfer a la cadena devuelta. + El número de caracteres de la siguiente línea es mayor que + 1 + + + Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. + Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. + El número de caracteres es mayor que . + Se ha desechado el lector de texto. + El lector está actualmente en uso por una operación de lectura anterior. + + + Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. + 2 + + + Inicializa una nueva instancia de la clase . + + + Inicializa una nueva instancia de la clase con el control de formato especificado. + Objeto que controla las operaciones de formato. + + + Almacena los caracteres de nueva línea usados para el TextWriter. + + + Libera todos los recursos utilizados por el objeto . + + + Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. + Codificación de caracteres donde se escriben los resultados. + 1 + + + Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + 1 + + + Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. + Tarea que representa la operación de vaciado asincrónico. + Se desecha el sistema de escritura de texto. + El sistema de escritura está actualmente en uso por una operación de escritura anterior. + + + Obtiene un objeto que controla las operaciones de formato. + Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. + 2 + + + Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. + Cadena de terminador de línea para el TextWriter actual. + 2 + + + Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. + 1 + + + Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. + Objeto que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena en la cadena o secuencia de texto. + Cadena que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + El valor de o es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un terminador de línea en la cadena o secuencia. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. + Valor Boolean que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. + Carácter que se va a escribir en la secuencia de texto. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. + Matriz de caracteres de la que se leen los datos. + Posición del carácter en donde comenzar a leer datos. + Número máximo de caracteres que se van a escribir. + La longitud del búfer menos es menor que . + El parámetro es null. + + o es negativo. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. + Valor decimal que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 8 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes con signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. + Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Valor de punto flotante de 4 bytes que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. + Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + El objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). + 1 + + + Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Primer objeto al que se va a dar formato y escribir. + Segundo objeto al que se va a dar formato y escribir. + Tercer objeto al que se va a dar formato y escribir. + El valor de es null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). + 1 + + + Escribe una cadena con formato y una nueva línea usando la misma semántica que . + Cadena de formato compuesto (vea Comentarios). + Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. + Una cadena u objeto se pasa como null. + El se cierra. + Se produce un error de E/S. + + no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. + 1 + + + Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 4 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. + Entero de 8 bytes sin signo que se va a escribir. + El se cierra. + Se produce un error de E/S. + 1 + + + Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. + Tarea que representa la operación de escritura asincrónica. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Carácter que se va a escribir en la secuencia de texto. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Matriz de caracteres de la que se escriben los datos. + Posición del carácter en el búfer donde comenzar la recuperación de datos. + Número de caracteres que se van a escribir. + El valor de es null. + El plus es mayor que la longitud del búfer. + + o es negativo. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. + Tarea que representa la operación de escritura asincrónica. + Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. + Se desecha el sistema de escritura de texto. + El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml new file mode 100644 index 00000000..30dc29ab --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml @@ -0,0 +1,2201 @@ + + + + System.IO + + + + Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux d'entrée. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + + Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. + Flux d'entrée. + Encodage des caractères à utiliser. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux d'entrée. + Encodage des caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. + + ou a la valeur null. + + + Expose l'accès au flux sous-jacent de l'élément . + Flux sous-jacent associé à l'élément BinaryReader. + 2 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. + Nombre d'octets à lire. + La fin du flux est atteinte avant que n'ait pu être lu. + Une erreur d'E/S se produit. + + demandé est plus grand que la taille de la mémoire tampon interne. + + + Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. + Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. + 2 + + + Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. + Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre d'octets à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. + Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. + Mémoire tampon dans laquelle lire les données. + Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. + Nombre de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + + a la valeur null. + + ou est négatif. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier 32 bits au format compressé. + Entier 32 bits au format compressé. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Le flux est endommagé. + + + Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. + true si l'octet est différent de zéro ; sinon, false. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. + Octet suivant lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. + Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. + Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Une erreur d'E/S se produit. + Le flux est fermé. + + est négatif. + 2 + + + Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. + Caractère lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + Un caractère de substitution a été lu. + 2 + + + Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. + Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. + Nombre de caractères à lire. + Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. + Le flux est fermé. + Une erreur d'E/S se produit. + + est négatif. + 2 + + + Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. + Valeur décimale lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Valeur à virgule flottante de 8 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. + Entier signé de 2 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Entier signé de 4 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. + Entier signé de 8 octets lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. + Octet signé lu dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. + Valeur à virgule flottante de 4 octets lue dans le flux actuel. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. + Chaîne en cours de lecture. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. + Entier non signé de 2 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. + Entier non signé de 4 octets lu dans ce flux. + La fin du flux est atteinte. + Le flux est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. + Entier non signé de 8 octets lu dans ce flux. + La fin du flux est atteinte. + Une erreur d'E/S se produit. + Le flux est fermé. + 2 + + + Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. + 2 + + + Initialise une nouvelle instance de la classe qui écrit dans un flux. + + + Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. + Flux de sortie. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + a la valeur null. + + + Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. + Flux de sortie. + Encodage de caractères à utiliser. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux de sortie. + Encodage de caractères à utiliser. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + + ou est null. + + + Obtient le flux sous-jacent de . + Flux sous-jacent associé à BinaryWriter. + 1 + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + 1 + + + Spécifie sans magasin de sauvegarde. + 1 + + + Contient le flux sous-jacent. + + + Définit la position dans le flux actuel. + Position dans le flux actuel. + Offset d'octet par rapport à . + Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. + Le pointeur de fichier a été déplacé vers un emplacement non valide. + La valeur n'est pas valide. + 1 + + + Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. + Valeur Boolean à écrire (0 ou 1). + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. + Octet non signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un tableau d'octets dans le flux sous-jacent. + Tableau d'octets contenant les données à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + a la valeur null. + 1 + + + Écrit une zone d'un tableau d'octets dans le flux actuel. + Tableau d'octets contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre d'octets à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Caractère Unicode de non-substitution à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + + est un caractère de substitution unique. + 1 + + + Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. + Tableau de caractères contenant les données à écrire. + + a la valeur null. + Le flux est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. + Tableau de caractères contenant les données à écrire. + Point de départ de à partir duquel l'écriture doit commencer. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. + Valeur décimale à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Valeur à virgule flottante de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. + Octet signé à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Valeur à virgule flottante de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. + Valeur à écrire. + Une erreur d'E/S se produit. + + a la valeur null. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. + Entier non signé de 2 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. + Entier non signé de 4 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. + Entier non signé de 8 octets à écrire. + Une erreur d'E/S se produit. + Le flux est fermé. + 1 + + + Écrit un nombre entier 32 bits dans un format compressé. + Entier 32 bits à écrire. + La fin du flux est atteinte. + Le flux est fermé. + Le flux est fermé. + + + Exception levée en cas de tentative de lecture au-delà de la fin du flux. + 2 + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. + + + Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Exception qui est levée lorsque le format d'un flux de données n'est pas valide. + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. + Tableau d'octets non signés à partir duquel créer le flux actuel. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + + a la valeur null. + + ou est inférieur à zéro. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. + Tableau d'octets non signés à partir duquel créer ce flux. + Index dans auquel commence le flux. + Longueur du flux en octets. + Définition de la propriété , qui détermine si le flux prend en charge l'écriture. + true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. + + a la valeur null. + + ou est négatif. + La longueur de la mémoire tampon moins est inférieure à . + + + Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. + Taille initiale du tableau interne, en octets. + + est négatif. + + + Obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux est ouvert. + 2 + + + Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 2 + + + Obtient ou définit le nombre d'octets alloués pour ce flux. + Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. + La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. + Le flux actuel est fermé. + set est appelé sur un flux dont la capacité ne peut pas être modifiée. + 2 + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. + Jeton pour surveiller les demandes d'annulation. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Remplace la méthode afin qu'aucune action ne soit effectuée. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation. + Le flux a été supprimé. + + + Obtient la longueur du flux en octets. + Longueur du flux en octets. + Le flux est fermé. + 2 + + + Obtient ou définit la position actuelle dans le flux. + Position actuelle dans le flux. + La position correspond à une valeur négative ou à une valeur supérieure à . + Le flux est fermé. + 2 + + + Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. + Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. + Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + + soustrait à la longueur de la mémoire tampon est inférieur à . + L'instance du flux actuel est fermée. + 2 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet dans le flux actuel. + Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. + L'instance du flux actuel est fermée. + 2 + + + Définit la position dans le flux actuel à la valeur spécifiée. + Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. + Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. + Valeur de type , qui sert de point de référence à la recherche. + Tentative de recherche avant le début du flux. + + est supérieur à . + Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. + L'instance du flux actuel est fermée. + 2 + + + Définit la longueur du flux actuel à la valeur spécifiée. + Valeur à laquelle définir la longueur. + Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. + + est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. + 2 + + + Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . + Nouveau tableau d'octets. + 2 + + + Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. + true si la conversion a réussi ; sinon, false. + Segment de tableau d'octets à partir duquel ce flux a été créé. + + + Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre maximal d'octets à écrire. + + a la valeur null. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. + + soustrait à la longueur de la mémoire tampon est inférieur à . + + ou est négatif. + Une erreur d'E/S se produit. + L'instance du flux actuel est fermée. + 2 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux actuel. + Octet à écrire. + Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. + Le flux actuel est fermé. + 2 + + + Écrit le contenu complet de ce flux de mémoire dans un autre flux. + Flux dans lequel écrire ce flux de mémoire. + + a la valeur null. + Le flux en cours ou le flux cible est fermé. + 2 + + + Spécifie la position au sein d'un flux à utiliser pour la recherche. + 2 + + + Spécifie le début d'un flux. + + + Spécifie la position actuelle au sein d'un flux. + + + Spécifie la fin d'un flux. + + + Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 2 + + + Initialise une nouvelle instance de la classe . + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. + true si le flux prend en charge la lecture ; sinon, false. + 1 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. + true si le flux prend en charge la recherche ; sinon, false. + 1 + + + Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. + 2 + + + En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. + true si le flux prend en charge l'écriture ; sinon, false. + 1 + + + Lit les octets du flux actuel et les écrit dans un autre flux. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Flux vers lequel le contenu du flux actuel sera copié. + Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. + Le flux actuel ou de a été fermé avant l'appel de la méthode . + Une erreur d'E/S s'est produite. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + + a la valeur null. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. + Tâche qui représente l'opération de copie asynchrone. + Flux vers lequel le contenu du flux actuel sera copié. + Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + est négatif ou égal à zéro. + Le flux de données actuel ou le flux de données de destination est supprimé. + Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. + Une erreur d'E/S se produit. + 2 + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. + Tâche qui représente l'opération de vidage asynchrone. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + Le flux a été supprimé. + + + En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. + Valeur de type long représentant la longueur du flux en octets. + Une classe dérivée de Stream ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Élément Stream sans magasin de stockage. + 1 + + + En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. + Position actuelle dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. + Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. + Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. + Nombre maximal d'octets à lire dans le flux actuel. + La somme de et de est supérieure à la longueur de la mémoire tampon. + + a la valeur null. + + ou est négatif. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Mémoire tampon dans laquelle les données sont écrites. + Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. + Nombre maximal d'octets à lire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + Le flux a été supprimé. + Le flux est en cours d'utilisation par une opération de lecture précédente. + + + Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. + Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. + Le flux ne prend pas en charge la lecture. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. + Nouvelle position dans le flux actuel. + Offset d'octet par rapport au paramètre . + Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 1 + + + En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. + Longueur souhaitée du flux actuel en octets. + Une erreur d'E/S se produit. + Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. + Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. + Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. + Nombre d'octets à écrire dans le flux actuel. + La somme des  et  est supérieure à la longueur du tampon. + + est null. + + ou  est un nombre négatif. + Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. + Le flux ne prend pas en charge l'écriture. + + a été appelée une fois que le flux a été fermé. + 1 + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. + Tâche qui représente l'opération d'écriture asynchrone. + Mémoire tampon dont sont issues les données à écrire. + Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. + Nombre maximal d'octets à écrire. + Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux ne prend pas en charge l'écriture. + Le flux a été supprimé. + Le flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. + Octet à écrire dans le flux. + Une erreur d'E/S se produit. + Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. + Des méthodes ont été appelées après que le flux a été fermé. + 2 + + + Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. + Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. + La méthode lève toujours . + 2 + + + Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié. + Flux à lire. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. + Flux à lire. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. + Flux à lire. + Encodage des caractères à utiliser. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + + ne prend pas en charge la lecture. + + ou a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. + Flux à lire. + Encodage des caractères à utiliser. + Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. + Taille minimale de la mémoire tampon. + Le flux ne prend pas en charge la lecture. + + ou a la valeur null. + + est inférieur ou égal à zéro. + + + Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Flux à lire. + Encodage des caractères à utiliser. + true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. + Taille minimale de la mémoire tampon. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + + Retourne le flux sous-jacent. + Flux sous-jacent. + 2 + + + Obtient l'encodage de caractères actuel utilisé par l'objet actuel. + Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . + 2 + + + Efface la mémoire tampon interne. + 2 + + + Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. + true si la position actuelle dans le flux est à la fin du flux ; sinon, false. + Le flux sous-jacent a été supprimé. + 1 + + + Objet autour d'un flux vide. + 1 + + + Retourne le caractère disponible suivant, mais ne le consomme pas. + Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. + Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. + Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Index de auquel commencer l'écriture. + Nombre maximal de caractères à lire. + La longueur de la mémoire tampon moins est inférieure à . + + a la valeur null. + + ou est négatif. + Une erreur d'E/S, telle que la fermeture du flux, se produit. + 1 + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. + Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S s'est produite. + + + Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. + Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. + Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du flux. + Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Une erreur d'E/S se produit. + 1 + + + Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. + Le nombre de caractères est supérieur à . + Le flux a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. + 1 + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. + Le flux dans lequel écrire. + + n'est pas accessible en écriture. + + a la valeur null. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + + ou est null. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. + Le flux dans lequel écrire. + Encodage des caractères à utiliser. + Taille de la mémoire tampon en octets. + true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. + + ou est null. + + est négatif. + + n'est pas accessible en écriture. + + + Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . + true pour forcer à vider sa mémoire tampon ; sinon, false. + 1 + + + Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. + Flux dans lequel ce StreamWriter écrit. + 2 + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + + + Obtient le dans lequel la sortie est écrite. + + spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. + 2 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. + Le writer actuel est fermé. + Une erreur d'E/S s'est produite. + L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. + 1 + + + Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le flux a été supprimé. + + + Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. + 1 + + + Écrit un caractère dans le flux. + Caractère à écrire dans le flux. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit un sous-tableau de caractères dans le flux. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Une erreur d'E/S se produit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + 1 + + + Écrit une chaîne dans le flux. + Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. + + a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. + + a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères contenant les données à écrire. + Position du caractère dans la mémoire où commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire dans le flux.Si est null, rien n'est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un terminateur de ligne dans le flux de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon où la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de flux est supprimé. + Le writer du flux est actuellement utilisé par une opération d'écriture précédente. + + + Implémente qui lit une chaîne. + 2 + + + Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. + Chaîne à laquelle doit être initialisé. + Le paramètre est null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Retourne le prochain caractère disponible, mais ne le consomme pas. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. + Le lecteur actuel est fermé. + 2 + + + Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. + Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. + Le lecteur actuel est fermé. + 2 + + + Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . + Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Index de début dans la mémoire tampon. + Nombre de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + Le lecteur actuel est fermé. + 2 + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. + Le lecteur actuel est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + 2 + + + Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. + Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le lecteur actuel est fermé. + 2 + + + Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. + Le nombre de caractères est supérieur à . + Le lecteur de chaîne a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. + Objet qui contrôle la mise en forme. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié. + StringBuilder dans lequel écrire. + + a la valeur null. + + + Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. + StringBuilder dans lequel écrire. + Objet qui contrôle la mise en forme. + + a la valeur null. + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le dans lequel la sortie est écrite. + Encoding dans lequel la sortie est écrite. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + + + Retourne le sous-jacent. + StringBuilder sous-jacent. + 2 + + + Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. + Chaîne contenant les caractères écrits dans le StringWriter en cours. + 2 + + + Écrit un caractère dans la chaîne. + Caractère à écrire. + Le writer est fermé. + 2 + + + Écrit un sous-tableau de caractères dans la chaîne. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + ou est négatif. + ( + )> .Length. + Le writer est fermé. + 2 + + + Écrit une chaîne dans la chaîne actuelle. + Chaîne à écrire. + Le writer est fermé. + 2 + + + Écrit un caractère dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne dans la chaîne actuelle de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans la chaîne. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position dans la mémoire tampon à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. + Le writer de chaîne est supprimé. + Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. + + + Représente un lecteur capable de lire une série séquentielle de caractères. + 2 + + + Initialise une nouvelle instance de la classe . + + + Libère toutes les ressources utilisées par . + + + Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Fournit un TextReader sans données à lire. + 1 + + + Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. + Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. + Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. + Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire. + + a la valeur null. + La longueur de la mémoire tampon moins est inférieure à . + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 2 + + + Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. + Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. + Position dans à partir de laquelle commencer l'écriture. + Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. + + a la valeur null. + + ou est négatif. + La somme de et de est supérieure à la longueur de la mémoire tampon. + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. + La ligne suivante du lecteur ou null si tous les caractères ont été lus. + Une erreur d'E/S se produit. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + + est fermé. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. + Le nombre de caractères contenus dans la ligne suivante est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. + Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. + Une erreur d'E/S se produit. + + est fermé. + La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. + Le nombre de caractères contenus dans la ligne suivante est supérieur à + 1 + + + Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. + Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. + Le nombre de caractères est supérieur à . + Le lecteur de texte a été supprimé. + Lecteur est en cours d'utilisation par une opération de lecture précédente. + + + Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. + 2 + + + Initialise une nouvelle instance de la classe . + + + Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. + Objet qui contrôle la mise en forme. + + + Stocke les caractères de saut de ligne utilisés pour ce TextWriter. + + + Libère toutes les ressources utilisées par l'objet . + + + Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. + Encodage de caractères dans lequel la sortie est écrite. + 1 + + + Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + 1 + + + Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. + Tâche qui représente l'opération de vidage asynchrone. + Le writer de texte est supprimé. + Le writer est actuellement utilisé par une opération d'écriture précédente. + + + Obtient un objet qui contrôle la mise en forme. + Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. + 2 + + + Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. + Chaîne de marque de fin de ligne pour le TextWriter actuel. + 2 + + + Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. + Objet à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne dans la chaîne ou le flux de texte. + Chaîne à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + + ou a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + La valeur Boolean à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Caractère à écrire dans le flux de texte. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Tableau de caractères dans lequel sont lues des données. + Dans , position de caractère à laquelle commencer la lecture des données. + Nombre maximal de caractères à écrire. + La longueur de la mémoire tampon moins est inférieure à . + Le paramètre a la valeur null. + + ou est négatif. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur décimale à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Valeur à virgule flottante de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Premier objet à mettre en forme et à écrire. + Deuxième objet à mettre en forme et à écrire. + Troisième objet à mettre en forme et à écrire. + + a la valeur null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). + 1 + + + Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . + Chaîne de format composite (consultez la section Notes). + Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. + Une chaîne ou un objet est passé en tant que null. + + est fermé. + Une erreur d'E/S se produit. + + n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . + 1 + + + Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 4 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. + Entier non signé de 8 octets à écrire. + + est fermé. + Une erreur d'E/S se produit. + 1 + + + Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Caractère à écrire dans le flux de texte. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Tableau de caractères à partir duquel les données doivent être écrites. + Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. + Nombre de caractères à écrire. + + a la valeur null. + + plus est supérieur à la longueur de la mémoire tampon. + + ou est négatif. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. + Tâche qui représente l'opération d'écriture asynchrone. + Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. + Le writer de texte est supprimé. + Le writer de texte est actuellement utilisé par une opération d'écriture précédente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml new file mode 100644 index 00000000..46070bec --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml @@ -0,0 +1,2123 @@ + + + + System.IO + + + + Legge i tipi di dati primitivi come valori binari in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. + Flusso di input. + Il flusso non supporta la lettura, è null o è già chiuso. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. + Flusso di input. + Codifica dei caratteri da usare. + Il flusso non supporta la lettura, è null o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. + Flusso di input. + Codifica dei caratteri da usare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la lettura, è null o è già chiuso. + + o è null. + + + Espone l'accesso al flusso sottostante dell'oggetto . + Flusso sottostante associato all'oggetto BinaryReader. + 2 + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Inserisce nel buffer interno il numero specificato di byte letti dal flusso. + Numero di byte da leggere. + È stata raggiunta la fine del flusso prima che fosse possibile leggere . + Si è verificato un errore di I/O. + I richiesti sono superiori alla dimensione del buffer interno. + + + Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. + Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. + 2 + + + Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. + Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. + Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di byte da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. + Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. + Buffer in cui leggere i dati. + Punto di partenza nel buffer dal quale avviare la lettura nel buffer. + Numero di caratteri da leggere. + La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + + è null. + Il valore di o è negativo. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero a 32 bit in formato compresso. + Intero a 32 bit in formato compresso. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + Flusso danneggiato. + + + Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + true se il byte è diverso da zero; in caso contrario, false. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. + Byte successivo letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. + Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. + Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è negativo. + 2 + + + Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Carattere letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + È stato letto un carattere surrogato. + 2 + + + Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. + Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. + Numero di caratteri da leggere. + Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. + Il flusso è chiuso. + Si è verificato un errore di I/O. + + è negativo. + 2 + + + Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. + Valore decimale letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. + Valore a virgola mobile a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. + Intero con segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Intero con segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. + Intero con segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. + Byte con segno letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. + Valore a virgola mobile a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. + Stringa da leggere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. + Intero senza segno a 2 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero senza segno a 4 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 2 + + + Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero senza segno a 8 byte letto dal flusso corrente. + È stata raggiunta la fine del flusso. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 2 + + + Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. + 2 + + + Inizializza una nuova istanza della classe che scrive in un flusso. + + + Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. + Flusso di output. + Il flusso non supporta la scrittura o è già chiuso. + + è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. + Flusso di output. + Codifica dei caratteri da utilizzare. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. + Flusso di output. + Codifica dei caratteri da utilizzare. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + Il flusso non supporta la scrittura o è già chiuso. + + o è null. + + + Ottiene il flusso sottostante dell'oggetto . + Flusso sottostante associato a BinaryWriter. + 1 + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Specifica un oggetto privo di archivio di backup. + 1 + + + Contiene il flusso principale. + + + Imposta la posizione all'interno del flusso corrente. + Posizione all'interno del flusso corrente. + Offset dei byte relativo a . + Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. + Il puntatore a file è stato spostato in un percorso non valido. + Il valore di non è valido. + 1 + + + Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. + Valore Boolean da scrivere (0 o 1). + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una matrice di byte nel flusso sottostante. + Matrice di caratteri che contiene i dati da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è null. + 1 + + + Scrive un'area di una matrice di byte nel flusso corrente. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale nel parametro da cui iniziare la scrittura. + Numero di byte da scrivere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Carattere Unicode non surrogato da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + + è un carattere surrogato singolo. + 1 + + + Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + + è null. + Il flusso è chiuso. + Si è verificato un errore di I/O. + 1 + + + Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Punto iniziale in dal quale avviare la scrittura. + Numero di caratteri da inserire. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. + Valore decimale da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Valore a virgola mobile a otto byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. + Byte con segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Valore a virgola mobile a quattro byte da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. + Valore da scrivere. + Si è verificato un errore di I/O. + + è null. + Il flusso è chiuso. + 1 + + + Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. + Intero a due byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. + Intero a quattro byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. + Intero a otto byte senza segno da scrivere. + Si è verificato un errore di I/O. + Il flusso è chiuso. + 1 + + + Inserisce un valore intero a 32 bit in un formato compresso. + Intero da 32 bit da scrivere. + È stata raggiunta la fine del flusso. + Il flusso è chiuso. + Il flusso è chiuso. + + + Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. + 2 + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. + + + Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Eccezione generata se un flusso di dati è in un formato non valido. + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. + Matrice di byte senza segno da cui creare il flusso corrente. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + + Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + + è null. + + o è minore di zero. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + + è null. + + o è un valore negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. + Matrice di byte senza segno da cui creare il flusso. + Indice in in corrispondenza del quale inizia il flusso. + Lunghezza del flusso in byte. + Impostazione della proprietà , che determina se il flusso supporta la scrittura. + true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. + + è null. + Il valore di o è negativo. + La lunghezza del buffer meno è minore di . + + + Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. + Dimensione iniziale in byte della matrice interna. + + è negativo. + + + Ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso è aperto. + 2 + + + Ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 2 + + + Ottiene o imposta il numero di byte allocati per questo flusso. + Lunghezza della parte usabile del buffer per il flusso. + È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. + Il flusso corrente è chiuso. + set è stato richiamato su un flusso del quale non è possibile modificare la capacità. + 2 + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. + Token da monitorare per le richieste di annullamento. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. + 2 + + + Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento. + Il flusso è stato eliminato. + + + Ottiene la lunghezza in byte del flusso. + Lunghezza del flusso in byte. + Il flusso è chiuso. + 2 + + + Ottiene o imposta la posizione corrente all'interno del flusso. + Posizione corrente all'interno del flusso. + La posizione è impostata su un valore negativo o maggiore di . + Il flusso è chiuso. + 2 + + + Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. + Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. + Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. + Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + + sottratto alla lunghezza del buffer è minore di . + L'istanza del flusso corrente è chiusa. + 2 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso corrente. + Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la posizione all'interno del flusso corrente sul valore specificato. + Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. + Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. + Valore di tipo , che funge da punto di riferimento per la ricerca. + La ricerca viene tentata prima dell'inizio del flusso. + + è maggiore di . + Il valore di non è valido. -oppure- causato da un overflow aritmetico. + L'istanza del flusso corrente è chiusa. + 2 + + + Imposta la lunghezza del flusso corrente sul valore specificato. + Valore su cui impostare la lunghezza. + Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. + + è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. + 2 + + + Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . + Nuova matrice di byte. + 2 + + + Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. + true se la conversione riesce; in caso contrario, false. + Segmento di matrice di byte da cui è stato creato questo flusso. + + + Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero massimo di byte da scrivere. + + è null. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. + + sottratto alla lunghezza del buffer è minore di . + + o è un valore negativo. + Si è verificato un errore di I/O. + L'istanza del flusso corrente è chiusa. + 2 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente all'interno del flusso corrente. + Byte da scrivere. + Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. + Il flusso corrente è chiuso. + 2 + + + Scrive l'intero contenuto del flusso di memoria in un altro flusso. + Flusso in cui scrivere il flusso di memoria. + + è null. + Il flusso corrente o di destinazione è chiuso. + 2 + + + Specifica la posizione in un flusso da utilizzare per le ricerche. + 2 + + + Specifica l'inizio di un flusso. + + + Specifica la posizione corrente all'interno di un flusso. + + + Specifica la fine di un flusso. + + + Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 2 + + + Inizializza una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. + true se il flusso supporta la lettura; in caso contrario, false. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. + true se il flusso supporta la ricerca; in caso contrario, false. + 1 + + + Ottiene un valore che determina se il flusso corrente prevede il timeout. + Valore che determina se il flusso corrente prevede il timeout. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. + true se il flusso supporta la scrittura; in caso contrario, false. + 1 + + + Legge i byte dal flusso corrente e li scrive in un altro flusso. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. + Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . + Si è verificato un errore di I/O. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + + è null. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. + Attività che rappresenta l'operazione di copia asincrona. + Flusso in cui verrà copiato il contenuto del flusso corrente. + Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + + è un valore negativo o zero. + Il flusso corrente o il flusso di destinazione viene eliminato. + Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Si è verificato un errore di I/O. + 2 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scaricamento asincrona. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + Il flusso è stato eliminato. + + + Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. + Valore long che rappresenta la lunghezza del flusso in byte. + Una classe derivata da Stream non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Oggetto Stream privo di archivio di backup. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. + Posizione corrente all'interno del flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. + Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. + Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. + Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. + Numero massimo di byte da leggere dal flusso corrente. + La somma di e è maggiore della lunghezza del buffer. + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Buffer in cui scrivere i dati. + Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. + Numero massimo di byte da leggere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la lettura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. + Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. + Il flusso non supporta la lettura. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. + Nuova posizione all'interno del flusso corrente. + Offset dei byte rispetto al parametro . + Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. + Si è verificato un errore di I/O. + Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. + Lunghezza desiderata del flusso corrente in byte. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. + Matrice di byte.Questo metodo copia i byte da nel flusso corrente. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. + Numero di byte da scrivere nel flusso corrente. + La somma di  e  è maggiore della lunghezza del buffer. + + è null. + + o  è negativo. + Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. + Il flusso non supporta la scrittura. + + è stato chiamato dopo la chiusura del flusso. + 1 + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. + Attività che rappresenta l'operazione di scrittura asincrona. + Buffer da cui scrivere i dati. + Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. + Numero massimo di byte da scrivere. + Token da monitorare per le richieste di annullamento.Il valore predefinito è . + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso non supporta la scrittura. + Il flusso è stato eliminato. + Il flusso è al momento utilizzato da un'operazione di scrittura precedente. + + + Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. + Byte da scrivere nel flusso. + Si è verificato un errore di I/O. + Il flusso non supporta la scrittura o è già chiuso. + Sono stati chiamati dei metodi dopo la chiusura del flusso. + 2 + + + Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. + Il metodo genera sempre un'eccezione . + 2 + + + Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato. + Flusso da leggere. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. + Flusso da leggere. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. + Flusso da leggere. + Codifica dei caratteri da usare. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + + non supporta la lettura. + + o è null. + + + Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. + Flusso da leggere. + Codifica dei caratteri da usare. + Indica se cercare i byte order mark all'inizio del file. + Dimensione minima del buffer. + Il flusso non supporta la lettura. + + o è null. + + è minore o uguale a zero. + + + Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. + Flusso da leggere. + Codifica dei caratteri da usare. + true per cercare i byte order mark all'inizio del file; in caso contrario, false. + Dimensione minima del buffer. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + + Restituisce il flusso sottostante. + Flusso sottostante. + 2 + + + Ottiene la codifica caratteri corrente usata dall'oggetto corrente. + Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . + 2 + + + Cancella il buffer interno. + 2 + + + Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. + true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. + Il flusso sottostante è stato eliminato. + 1 + + + Oggetto che include un flusso vuoto. + 1 + + + Restituisce il carattere successivo disponibile senza usarlo. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. + Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Indice di da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + La lunghezza del buffer meno è minore di . + + è null. + Il valore di o è negativo. + Si è verificato un errore di I/O, come la chiusura del flusso. + 1 + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + + + Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. + Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. + Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Si è verificato un errore di I/O. + 1 + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. + Il numero di caratteri è maggiore di . + Il flusso è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. + 1 + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. + Flusso in cui scrivere. + + non è modificabile. + + è null. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + + o è null. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + + o è null. + + è negativo. + + non è modificabile. + + + Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. + Flusso in cui scrivere. + Codifica dei caratteri da usare. + Dimensioni del buffer, in byte. + true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. + + o è null. + + è negativo. + + non è modificabile. + + + Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . + true per forzare lo scaricamento del buffer; in caso contrario, false. + 1 + + + Ottiene il flusso sottostante che si interfaccia con un archivio di backup. + Flusso in cui StreamWriter scrive. + 2 + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + + + Ottiene l'oggetto in cui viene scritto l'output. + Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. + 2 + + + Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. + Il writer corrente è chiuso. + Si è verificato un errore di I/O. + La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il flusso è stato eliminato. + + + Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive un carattere nel flusso. + Carattere da scrivere nel flusso. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una matrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una sottomatrice di caratteri nel flusso. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Si è verificato un errore di I/O. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + 1 + + + Scrive una stringa nel flusso. + Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. + + è true o il buffer di è pieno e il writer corrente è chiuso. + + è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri che contiene i dati da scrivere. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di flusso viene eliminato. + Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. + + + Implementa un oggetto che legge da una stringa. + 2 + + + Inizializza una nuova istanza della classe che legge dalla stringa specificata. + Stringa sulla quale inizializzare . + Il parametro è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Restituisce il carattere successivo disponibile senza utilizzarlo. + Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. + Il lettore corrente è chiuso. + 2 + + + Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. + Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. + Il lettore corrente è chiuso. + 2 + + + Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . + Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Indice iniziale nel buffer. + Numero di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. + Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. + Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. + Il lettore corrente è chiuso. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + 2 + + + Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Contenuto dalla posizione corrente alla fine della stringa sottostante. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il lettore corrente è chiuso. + 2 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. + Il numero di caratteri è maggiore di . + Il lettore della stringa è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il controllo di formato specificato. + Oggetto che controlla la formattazione. + + + Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. + Oggetto StringBuilder in cui scrivere. + + è null. + + + Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. + Oggetto StringBuilder in cui scrivere. + Oggetto che controlla la formattazione. + + è null. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. + + + Recupera l'oggetto in cui viene scritto l'output. + Encoding in cui viene scritto l'output. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di svuotamento asincrona. + + + Restituisce l'oggetto sottostante. + StringBuilder sottostante. + 2 + + + Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. + Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. + 2 + + + Scrive un carattere nella stringa. + Carattere da inserire. + Il writer è chiuso. + 2 + + + Scrive una sottomatrice di caratteri nella stringa. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + Il valore di o è negativo. + ( + )> .Length. + Il writer è chiuso. + 2 + + + Scrive una stringa nella stringa corrente. + Stringa da scrivere. + Il writer è chiuso. + 2 + + + Scrive un carattere nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri nella stringa in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa nella stringa corrente in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nella stringa. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione nel buffer da cui iniziare la lettura dei dati. + Numero massimo di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di stringa viene eliminato. + Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. + + + Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. + 2 + + + Inizializza una nuova istanza della classe . + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. + 1 + + + Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. + Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. + Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. + Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. + Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere. + + è null. + La lunghezza del buffer meno è minore di . + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 2 + + + Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. + Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. + Posizione in da cui iniziare la scrittura. + Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. + + è null. + Il valore di o è negativo. + La somma di e è maggiore della lunghezza del buffer. + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. + Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. + Si è verificato un errore di I/O. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + La classe è chiusa. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. + Il numero di caratteri nella riga successiva è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. + Si è verificato un errore di I/O. + La classe è chiusa. + La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. + Il numero di caratteri nella riga successiva è maggiore di + 1 + + + Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. + Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. + Il numero di caratteri è maggiore di . + Il lettore di testo è stato eliminato. + Il lettore è al momento utilizzato da un'operazione di lettura precedente. + + + Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. + 2 + + + Inizializza una nuova istanza della classe . + + + Inizializza una nuova istanza della classe con il provider di formato specificato. + Oggetto che controlla la formattazione. + + + Archivia i caratteri di nuova riga usati per questo TextWriter. + + + Rilascia tutte le risorse usate dall'oggetto . + + + Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. + Codifica caratteri in cui viene scritto l'output. + 1 + + + Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + 1 + + + Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. + Attività che rappresenta l'operazione di scaricamento asincrona. + Il writer di testo viene eliminato. + Il writer è attualmente utilizzato da un'operazione di scrittura precedente. + + + Ottiene un oggetto che controlla la formattazione. + Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. + 2 + + + Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. + Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. + 2 + + + Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere nella stringa o flusso di testo. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri nella stringa o flusso di testo. + Matrice di caratteri da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. + Oggetto da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa nella stringa o nel flusso di testo. + Stringa da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + + o è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive un terminatore di riga nel flusso o nella stringa di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore Boolean da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. + Carattere da scrivere nel flusso di testo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Matrice di caratteri da cui vengono letti i dati. + Posizione del carattere in dalla quale avviare la lettura dei dati. + Numero massimo di caratteri da scrivere. + La lunghezza del buffer meno è minore di . + Il valore del parametro è null. + Il valore di o è negativo. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore decimale da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 8 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte con segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Valore a virgola mobile a 4 byte da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). + 1 + + + Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Primo oggetto da formattare e scrivere. + Secondo oggetto da formattare e scrivere. + Terzo oggetto da formattare e scrivere. + + è null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). + 1 + + + Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . + Stringa in formato composito (vedere la sezione Note). + Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. + Viene passato un oggetto o una stringa come null. + La classe è chiusa. + Si è verificato un errore di I/O. + + non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . + 1 + + + Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 4 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. + Intero a 8 byte senza segno da scrivere. + La classe è chiusa. + Si è verificato un errore di I/O. + 1 + + + Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Carattere da scrivere nel flusso di testo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Matrice di caratteri da cui scrivere i dati. + Posizione del carattere nel buffer da cui iniziare il recupero dei dati. + Numero di caratteri da scrivere. + + è null. + + e sono maggiori della lunghezza del buffer. + Il valore di o è negativo. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. + Attività che rappresenta l'operazione di scrittura asincrona. + Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. + Il writer di testo viene eliminato. + Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml new file mode 100644 index 00000000..4114d626 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml @@ -0,0 +1,2264 @@ + + + + System.IO + + + + プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 + 2 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 入力ストリーム。 + 使用する文字エンコーディング。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + は null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 入力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 + + または が null です。 + + + + の基になるストリームへのアクセスを公開します。 + BinaryReader に関連付けられた、基になるストリーム。 + 2 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 + 読み取るバイト数。 + + 分のバイトを読み取る前にストリームの末尾に到達しました。 + I/O エラーが発生しました。 + 要求された が、内部バッファー サイズより大きくなっています。 + + + 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 + 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 + 2 + + + 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 + + に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取るバイト数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 + バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを読み取るバッファー。 + バッファー内の、バッファーへの読み取り開始点。 + 読み取る文字の数。 + バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + + は null です。 + + または が負の値です。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 32 ビット整数を圧縮形式で読み取ります。 + 圧縮形式の 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + ストリームが破損しています。 + + + 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った次のバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 + 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + が負の値です。 + 2 + + + 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 + 現在のストリームから読み取った文字。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + サロゲート文字が読み取られました。 + 2 + + + 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 + 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 + 読み取る文字の数。 + デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + + が負の値です。 + 2 + + + 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 + 現在のストリームから読み取った 10 進数値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号付き整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 + 現在のストリームから読み取った符号付きバイト。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト浮動小数点値。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 + 読み取った文字列。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 + 現在のストリームから読み取った 2 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 + 現在のストリームから読み取った 4 バイト符号なし整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 2 + + + 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 + 現在のストリームから読み取った 8 バイト符号なし整数。 + ストリームの末尾に到達しました。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 2 + + + プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 + 2 + + + ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 + + + 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + は null なので、 + + + 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 + 出力ストリーム。 + 使用する文字エンコーディング。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 出力ストリーム。 + 使用する文字エンコーディング。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + + または が null です。 + + + + の基になるストリームを取得します。 + BinaryWriter に関連付けられた、基になるストリーム。 + 1 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + バッキング ストアを持たない を指定します。 + 1 + + + 基になるストリームを保持します。 + + + 現在のストリーム内の位置を設定します。 + 現在のストリームの位置。 + + からのバイト オフセット。 + 新しい位置を取得するための参照ポイントを示す フィールド。 + ファイル ポインターが無効な位置に移動しました。 + + 値が無効です。 + 1 + + + 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 + 書き込む Boolean 値 (0 または 1)。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号なしバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 基になるストリームにバイト配列を書き込みます。 + 書き込むデータが格納されているバイト配列。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は null なので、 + 1 + + + 現在のストリームにバイト配列の特定の領域を書き込みます。 + 書き込むデータが格納されているバイト配列。 + + 内の書き込み開始点。 + 書き込むバイト数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む非サロゲート Unicode 文字。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + + は、単一のサロゲート文字です。 + 1 + + + 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + は null なので、 + ストリームが閉じられました。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込むデータを格納する文字配列。 + + 内の書き込み開始点。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null なので、 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 + 書き込む 10 進値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号付き整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + 書き込む符号付きバイト。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト浮動小数点値。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 + 書き込む値。 + I/O エラーが発生しました。 + + は null なので、 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 + 書き込む 2 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 + 書き込む 4 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 + 書き込む 8 バイト符号なし整数。 + I/O エラーが発生しました。 + ストリームが閉じられました。 + 1 + + + 32 ビット整数を圧縮形式で書き込みます。 + 書き込む 32 ビット整数。 + ストリームの末尾に到達しました。 + ストリームが閉じられました。 + ストリームが閉じられました。 + + + ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 + 2 + + + メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 + + + メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データ ストリームが無効な形式である場合にスローされる例外。 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 + + + 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + 現在のストリームを作成する符号なしバイトの配列。 + + は null です。 + + + + プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + + バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + + は null です。 + + または が 0 未満です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 + このストリームの作成元の符号なしバイトの配列。 + ストリームが開始する位置の のインデックス。 + バイト単位のストリーム長。 + ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 + ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + + + + クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 + バイト単位の内部配列の初期サイズ。 + + が負の値です。 + + + 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 + ストリームが開いている場合は true。 + 2 + + + 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 2 + + + ストリームに割り当てられたバイト数を取得または設定します。 + ストリームに対してバッファーが使用できる部分の長さ。 + 容量が負の値または現在のストリーム長より小さい値に設定されています。 + 現在のストリームが閉じています。 + 容量を変更できないストリームに対して set が呼び出されました。 + 2 + + + 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 + キャンセル要求を監視するためのトークン。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + アクションが実行されないように、 メソッドをオーバーライドします。 + 2 + + + このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。 + ストリームは破棄されています。 + + + バイト単位のストリーム長を取得します。 + バイト単位のストリーム長。 + ストリームが閉じられました。 + 2 + + + ストリームの現在位置を取得または設定します。 + ストリーム内の現在位置。 + 位置が負の値または より大きい値に設定されています。 + ストリームが閉じられました。 + 2 + + + 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 + バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 + このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 + 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + バッファー長から を差し引いた値が より小さい値です。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームからバイトを読み取ります。 + + にキャストしたバイト。ストリームの末尾に達した場合は -1。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム内の位置を指定した値に設定します。 + 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 + ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 + シーク参照ポイントとして機能する 型の値。 + ストリームの先頭より前をシークしようとしました。 + + が より大きくなっています。 + 無効な があります。または によって算術オーバーフローが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリーム長を指定した値に設定します。 + 長さを設定する値。 + 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 + + が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 + 2 + + + + プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 + 新しいバイト配列。 + 2 + + + このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 + 変換が成功した場合は true。それ以外の場合は false。 + このストリームの作成元のバイト配列セグメント。 + + + バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 + データの書き込み元となるバッファー。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + 現在のストリーム インスタンスが閉じています。 + 2 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリーム内の現在位置に 1 バイトを書き込みます。 + 書き込むバイト。 + ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 + 現在のストリームが閉じています。 + 2 + + + メモリ ストリームの内容全体を別のストリームに書き込みます。 + このメモリ ストリームが書き込まれるストリーム。 + + は null です。 + 現在のストリームまたは対象のストリームは閉じています。 + 2 + + + シークに使用するストリームの場所を指定します。 + 2 + + + ストリームの先頭を指定します。 + + + ストリーム内の現在位置を指定します。 + + + ストリームの末尾を指定します。 + + + バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 + ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 + ストリームがシークをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 + 現在のストリームがタイムアウトできるかどうかを決定する値。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 + ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 + 1 + + + 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 + + メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 + I/O エラーが発生しました。 + + + 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + + は null です。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 + 非同期のコピー操作を表すタスク。 + 現在のストリームの内容のコピー先のストリーム。 + バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + が負の値またはゼロです。 + 現在のストリームまたはコピー先ストリームは破棄されます。 + 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 + + + + によって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + I/O エラーが発生しました。 + 2 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 + 非同期のフラッシュ操作を表すタスク。 + キャンセル要求を監視するためのトークン。既定値は です。 + ストリームは破棄されています。 + + + 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 + ストリーム長 (バイト単位) を表す long 値。 + Stream から派生したクラスがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + バッキング ストアを持たない Stream。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 + ストリーム内の現在位置。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 + バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 + バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 + 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームから読み取る最大バイト数。 + + と の合計値が、バッファー長より大きい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + データを書き込むバッファー。 + ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 + 読み取る最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは読み取りをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の読み取り操作で使用中です。 + + + ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 + Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 + ストリームは読み取りをサポートしません。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 + 現在のストリーム内の新しい位置。 + + パラメーターからの相対バイト オフセット。 + 新しい位置を取得するために使用する参照ポイントを示す 型の値。 + I/O エラーが発生しました。 + ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 1 + + + 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 + 現在のストリームの希望の長さ (バイト数)。 + I/O エラーが発生しました。 + ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 + バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 + 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 現在のストリームに書き込むバイト数。 + 合計  と  がバッファーの長さより大きい。 + + nullです。 + + または  が負の値です。 + 指定したファイルが見つからないなど、I/O エラーが発生しました。 + ストリームは書き込みをサポートしません。 + + ストリームが閉じられた後が呼び出されました。 + 1 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元となるバッファー。 + ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 + 書き込む最大バイト数。 + キャンセル要求を監視するためのトークン。既定値は です。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは書き込みをサポートしません。 + ストリームは破棄されています。 + ストリームは現在、前の書き込み操作で使用中です。 + + + ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 + ストリームに書き込むバイト。 + I/O エラーが発生しました。 + ストリームが書き込みをサポートしていないか、既に閉じています。 + ストリームが閉じられた後でメソッドが呼び出されました。 + 2 + + + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 + ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 + + メソッドは、常に をスローします。 + 2 + + + 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 + 1 + + + 指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + + が読み取りをサポートしていません。 + + は null です。 + + + バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + は null です。 + + + 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + + が読み取りをサポートしていません。 + + または が null です。 + + + 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 読み込まれるストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 + 最小バッファー サイズ。 + ストリームは読み取りをサポートしません。 + + または が null です。 + + が 0 以下です。 + + + 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 読み取るストリーム。 + 使用する文字エンコーディング。 + ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 + 最小バッファー サイズ。 + + オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 + + + 基になるストリームを返します。 + 基になるストリーム。 + 2 + + + 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 + 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 + 2 + + + 内部バッファーをクリアします。 + 2 + + + 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 + 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 + 基になるストリームは破棄されています。 + 1 + + + 空のストリームの オブジェクト。 + 1 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 + 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 + I/O エラーが発生しました。 + 1 + + + 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 + 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みの開始位置を示す のインデックス。 + 読み取り対象の最大文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + は null です。 + + または が負の値です。 + I/O エラーが発生しました。たとえば、ストリームがクローズされています。 + 1 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + + + 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 + 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + すべての文字の現在位置から末尾までを読み込みます。 + ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + I/O エラーが発生しました。 + 1 + + + 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + ストリームは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 + 1 + + + UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + + が書き込み可能ではありません。 + + は null です。 + + + 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + + または が null です。 + + が書き込み可能ではありません。 + + + 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 + 書き込まれるストリーム。 + 使用する文字エンコーディング。 + バイト単位のバッファー サイズ。 + true to leave the stream open after the object is disposed; otherwise, false. + + または が null です。 + + が負の値です。 + + が書き込み可能ではありません。 + + + + が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 + + に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 + 1 + + + バッキング ストアと連結する、基になるストリームを取得します。 + この StreamWriter が書き込むストリーム。 + 2 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + + + 出力の書き込みに使用する を取得します。 + 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 + 2 + + + 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 + 現在のライターがクローズされています。 + I/O エラーが発生しました。 + 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 + 1 + + + このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + ストリームは破棄されています。 + + + バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 + 1 + + + ストリームに文字を書き込みます。 + ストリームに書き込む文字。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列を書き込みます。 + 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字配列の一部を書き込みます。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + I/O エラーが発生しました。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + 1 + + + ストリームに文字列を書き込みます。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + + が true または バッファーがいっぱいで、現在のライターが閉じられています。 + + が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 + I/O エラーが発生しました。 + 1 + + + 文字を非同期でストリームに書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込むデータを格納する文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をストリームに非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + ストリームに書き込む文字。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の文字位置。 + 書き込む文字の最大数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + ストリーム ライターは破棄されます。 + ストリーム ライターは現在、前の書き込み操作で使用中です。 + + + 文字列から読み取る を実装します。 + 2 + + + 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 + + を初期化する目的の文字列。 + + パラメーターが null です。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り可能な次の文字を返しますが、その文字は使用されません。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 + 基になる文字列の次の文字。または使用できる文字がない場合は -1。 + 現在のリーダーが閉じています。 + 2 + + + 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 + バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + バッファー内の開始インデックス。 + 読み取る文字の数。 + + は null なので、 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + 現在のリーダーが閉じています。 + 2 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 + + は null なので、 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 + 現在の文字列の次の行。文字列の末尾に到達した場合は null。 + 現在のリーダーが閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 2 + + + 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 + 基になる文字列の現在位置から末尾までの内容。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 現在のリーダーが閉じています。 + 2 + + + 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + 文字列リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + + は null なので、 + + + 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 + 書き込む StringBuilder。 + 書式を制御する オブジェクト。 + + は null なので、 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 出力の書き込みに使用する を取得します。 + 出力の書き込み時に適用する Encoding。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + + + 基になる を返します。 + 基になる StringBuilder。 + 2 + + + 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 + 現在の StringWriter に書き込まれた文字を格納している文字列。 + 2 + + + 文字列に文字を書き込みます。 + 書き込む文字。 + ライターが閉じられました。 + 2 + + + 文字配列の一部を文字列に書き込みます。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + または が負の値です。 + ( + )> 。Length. + ライターが閉じられました。 + 2 + + + 現在の文字列に文字列を書き込みます。 + 書き込む文字列。 + ライターが閉じられました。 + 2 + + + 文字列に文字を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に文字列を非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 文字列に書き込む文字。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの読み取りを開始する、バッファー内の位置。 + 書き込む文字の最大数。 + + は null なので、 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + 文字列ライターは破棄されます。 + 文字列ライターは現在、前の書き込み操作で使用中です。 + + + 一連の文字を読み取ることができるリーダーを表します。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 読み取り対象のデータを TextReader に提供しません。 + 1 + + + リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 + 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 + テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 + このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。 + + は null です。 + バッファー長から を差し引いた値が より小さい値です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 2 + + + 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 + このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 + 書き込みを開始する 内の位置。 + 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 + + は null です。 + + または が負の値です。 + + と の合計値が、バッファー長より大きい値です。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 + リーダーの次の行。またはすべての文字が読み取られた場合は null。 + I/O エラーが発生しました。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + + が閉じています。 + 次の行の文字数が、 を超えています。 + 1 + + + 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 + 次の行の文字数が、 を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 + テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 + I/O エラーが発生しました。 + + が閉じています。 + 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 + 次の行の文字数が、 を超えています。 + 1 + + + テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 + 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 + 文字数が を超えています。 + テキスト リーダーは破棄されています。 + リーダーは現在、前の読み取り操作で使用中です。 + + + 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 + 2 + + + + クラスの新しいインスタンスを初期化します。 + + + 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 + 書式を制御する オブジェクト。 + + + この TextWriter で使用する改行文字を格納します。 + + + この オブジェクトによって使用されているすべてのリソースを解放します。 + + + + で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 + 出力の書き込み時に適用する文字エンコーディング。 + 1 + + + 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 1 + + + 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 + 非同期のフラッシュ操作を表すタスク。 + テキスト ライターは破棄されます。 + ライターは現在、前の書き込み操作で使用中です。 + + + 書式を制御するオブジェクトを取得します。 + 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 + 2 + + + 現在の TextWriter で使用される行終端文字列を取得または設定します。 + 現在の TextWriter で使用する行終端文字列。 + 2 + + + バッキング ストアを持たない書き込み専用の TextWriter を提供します。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字配列をテキスト文字列またはストリームに書き込みます。 + テキスト ストリームに書き込む文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込みます。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込むオブジェクト。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込みます。 + 書き込む文字列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + + または が null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 行終端記号をテキスト文字列またはストリームに書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む Boolean 値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + テキスト ストリームに書き込む文字。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + データの読み取り元の文字配列。 + データの読み込みを開始する、 内の文字の位置。 + 書き込む文字の最大数。 + バッファー長から を差し引いた値が より小さい値です。 + + パラメーターが null です。 + + または が負の値です。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 10 進値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号付き整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト浮動小数点値。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをするオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 + 1 + + + + メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする最初のオブジェクト。 + 書式設定および書き込みをする 2 番目のオブジェクト。 + 書式設定および書き込みをする 3 番目のオブジェクト。 + + は null です。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 + 1 + + + + と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 + 複合書式指定文字列 (「解説」を参照)。 + 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 + 文字列またはオブジェクトが null として渡されました。 + + が閉じています。 + I/O エラーが発生しました。 + + は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 + 1 + + + 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 4 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 + 書き込む 8 バイト符号なし整数。 + + が閉じています。 + I/O エラーが発生しました。 + 1 + + + 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + データの書き込み元の文字配列。 + データの取得を開始する、バッファー内の文字位置。 + 書き込む文字数。 + + は null です。 + + に を加算した値が、バッファーの長さを超えています。 + + または が負の値です。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 + 非同期の書き込み操作を表すタスク。 + 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 + テキスト ライターは破棄されます。 + テキスト ライターは現在、前の書き込み操作で使用中です。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml new file mode 100644 index 00000000..145ab498 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml @@ -0,0 +1,2262 @@ + + + + System.IO + + + + 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. + 2 + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 가 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 입력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 + + 또는 가 null인 경우 + + + + 의 내부 스트림에 대한 액세스를 노출합니다. + BinaryReader와 관련된 내부 스트림입니다. + 2 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. + 읽을 바이트 수입니다. + + 를 읽기 전에 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 요청된 가 내부 버퍼 크기보다 큰 경우 + + + 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. + 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. + 2 + + + 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. + + 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 데이터를 읽어올 버퍼입니다. + 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. + 읽을 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 압축 형식의 32비트 정수를 읽습니다. + 압축 형식의 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 스트림이 손상되었습니다. + + + 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 바이트가 0이 아니면 true이고 0이면 false입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 다음 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. + 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 현재 스트림에서 읽은 문자입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 서로게이트 문자를 읽은 경우 + 2 + + + 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. + 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. + 읽을 문자 수입니다. + 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + + 가 음수인 경우 + 2 + + + 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 10진 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 있는 바이트입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. + 읽어 오는 문자열입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. + 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. + 스트림의 끝에 도달한 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. + 2 + + + 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 가 null입니다. + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 출력 스트림입니다. + 사용할 문자 인코딩입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + + 또는 이 null인 경우 + + + + 의 내부 스트림을 가져옵니다. + BinaryWriter와 관련된 내부 스트림입니다. + 1 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 1 + + + 백업 저장소가 없는 를 지정합니다. + 1 + + + 내부 스트림을 보유합니다. + + + 현재 스트림 내에서 위치를 설정합니다. + 현재 스트림에서의 위치입니다. + + 에 상대적인 바이트 오프셋입니다. + 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. + 파일 포인터가 잘못된 위치로 이동한 경우 + + 값이 잘못된 경우 + 1 + + + false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. + 쓸 Boolean 값(0 또는 1)입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 없는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 내부 스트림에 바이트 배열을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 null입니다. + 1 + + + 현재 스트림에 바이트 배열 영역을 씁니다. + 쓸 데이터를 포함하는 바이트 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 바이트 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + + 가 단일 서로게이트 문자인 경우 + 1 + + + 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + + 가 null입니다. + 스트림이 닫혀 있는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 쓰기를 시작할 의 시작점입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null입니다. + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. + 출력할 10진수 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 있는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. + 쓸 부호 있는 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부동 소수점 값입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + + 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. + 쓸 값입니다. + I/O 오류가 발생하는 경우 + + 가 null입니다. + 스트림이 닫혀 있는 경우 + 1 + + + 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. + 쓸 2바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. + 쓸 4바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. + 쓸 8바이트 부호 없는 정수입니다. + I/O 오류가 발생하는 경우 + 스트림이 닫혀 있는 경우 + 1 + + + 압축 형식의 32비트 정수를 씁니다. + 쓸 32비트 정수입니다. + 스트림의 끝에 도달한 경우 + 스트림이 닫혀 있는 경우 + 스트림이 닫혀 있는 경우 + + + 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. + 2 + + + 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + + 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 현재 스트림을 만들 부호 없는 바이트의 배열입니다. + + 가 null인 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + + 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + + 가 null인 경우 + + 또는 가 0보다 작은 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. + 이 스트림을 만들 부호 없는 바이트의 배열입니다. + 스트림이 시작될 의 인덱스입니다. + 스트림의 길이(바이트)입니다. + 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. + 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + + 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 내부 배열의 초기 크기(바이트)입니다. + + 가 음수인 경우 + + + 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 열려 있으면 true입니다. + 2 + + + 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 2 + + + 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. + 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. + 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 + 현재 스트림이 닫혀 있는 경우 + 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 + 2 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. + 취소 요청을 모니터링할 토큰입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다. + 스트림이 삭제된 경우 + + + 스트림의 길이(바이트)를 가져옵니다. + 스트림의 길이(바이트)입니다. + 스트림이 닫혀 있는 경우 + 2 + + + 스트림 내의 현재 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + 위치가 음수 값이나 보다 큰 값으로 설정된 경우 + 스트림이 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. + 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. + 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트를 읽습니다. + + 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림 내의 위치를 지정된 값으로 설정합니다. + 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. + 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. + 검색 참조 지점 역할을 하는 형식의 값입니다. + 스트림의 시작 전에 검색하려고 한 경우 + + 가 보다 큰 경우 + 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 현재 스트림의 길이를 지정된 값으로 설정합니다. + 길이를 설정할 값입니다. + 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 + + 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. + 2 + + + + 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. + 새 바이트 배열입니다. + 2 + + + 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. + 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. + 이 스트림을 만든 바이트 배열 세그먼트입니다. + + + 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. + 데이터를 쓸 버퍼입니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 + 버퍼 길이에서 을 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 현재 스트림 인스턴스가 닫혀 있는 경우 + 2 + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 위치에서 현재 스트림에 바이트를 씁니다. + 쓸 바이트입니다. + 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 + 현재 스트림이 닫혀 있는 경우 + 2 + + + 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. + 이 메모리 스트림을 쓸 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 닫혀 있는 경우 + 2 + + + 탐색에 사용할 스트림 내 위치를 지정합니다. + 2 + + + 스트림의 맨 앞을 지정합니다. + + + 스트림 내의 현재 위치를 지정합니다. + + + 스트림의 맨 끝을 지정합니다. + + + 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. + 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. + 2 + + + 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. + 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. + 1 + + + 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 + + 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + + 가 null인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. + 비동기 복사 작업을 나타내는 작업입니다. + 현재 스트림의 내용을 복사할 스트림입니다. + 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 가 음수이거나 0인 경우 + 현재 스트림이나 대상 스트림이 삭제됩니다. + 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. + + + + 에서 사용하는 모든 리소스를 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. + I/O 오류가 발생하는 경우 + 2 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + 스트림이 삭제된 경우 + + + 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. + 스트림 길이(바이트)를 나타내는 long 값입니다. + Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 백업 저장소가 없는 Stream입니다. + 1 + + + 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. + 스트림 내의 현재 위치입니다. + I/O 오류가 발생하는 경우 + 스트림이 검색을 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. + 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. + 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. + 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에서 읽을 최대 바이트 수입니다. + + 와 의 합계가 버퍼 길이보다 큰 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 데이터를 쓸 버퍼입니다. + 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. + 읽을 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 읽기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. + Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. + 스트림이 읽기를 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. + 현재 스트림 내의 새 위치입니다. + + 매개 변수에 상대적인 바이트 오프셋입니다. + 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. + 스트림이 닫힌 후 메서드가 호출된 경우 + 1 + + + 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. + 원하는 현재 스트림의 길이(바이트)입니다. + I/O 오류가 발생하는 경우 + 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. + 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. + 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 현재 스트림에 쓸 바이트 수입니다. + 총  및  버퍼 길이 보다 큽니다. + + null입니다. + + 또는  음수입니다. + 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. + 스트림이 쓰기를 지원하지 않습니다. + + 스트림이 닫힌 후 호출 되었습니다. + 1 + + + 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 데이터를 쓸 버퍼입니다. + 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. + 쓸 최대 바이트 수입니다. + 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 쓰기를 지원하지 않습니다. + 스트림이 삭제된 경우 + 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. + + + 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. + 스트림에 쓸 바이트입니다. + I/O 오류가 발생하는 경우 + 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 + 스트림이 닫힌 후 메서드가 호출된 경우 + 2 + + + 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. + 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. + + 메서드는 항상 을 throw합니다. + 2 + + + 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. + 1 + + + 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 가 null인 경우 + + + 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + + 이 읽기를 지원하지 않는 경우 + + 또는 가 null인 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. + 최소 버퍼 크기입니다. + 스트림이 읽기를 지원하지 않습니다. + + 또는 가 null인 경우 + + 가 0보다 작거나 같은 경우 + + + 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. + 읽을 스트림입니다. + 사용할 문자 인코딩입니다. + 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. + 최소 버퍼 크기입니다. + + 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. + + + 내부 스트림을 반환합니다. + 내부 스트림입니다. + 2 + + + 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. + 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. + 2 + + + 내부 버퍼를 지웁니다. + 2 + + + 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. + 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. + 내부 스트림이 삭제된 경우 + 1 + + + 빈 스트림 주위의 개체입니다. + 1 + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + + 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. + 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 인덱스입니다. + 읽을 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 가 null인 경우 + + 또는 가 음수인 경우 + 스트림이 닫히는 등의 I/O 오류가 발생한 경우 + 1 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + + 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. + 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 스트림이 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + + 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. + 1 + + + UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + + 에 쓸 수 없는 경우 + + 가 null인 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + + 또는 가 null인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. + 쓸 스트림입니다. + 사용할 문자 인코딩입니다. + 버퍼 크기(바이트)입니다. + true to leave the stream open after the object is disposed; otherwise, false. + + 또는 가 null인 경우 + + 가 음수인 경우 + + 에 쓸 수 없는 경우 + + + + 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. + + 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. + 1 + + + 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. + 이 StreamWriter가 쓰고 있는 스트림입니다. + 2 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + + + 출력이 쓰여질 을 가져옵니다. + 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. + 2 + + + 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. + 현재 writer가 닫힌 경우 + I/O 오류가 발생한 경우 + 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 + 1 + + + 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 스트림이 삭제된 경우 + + + StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. + 1 + + + 스트림에 문자를 씁니다. + 스트림에 쓸 문자입니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자의 하위 배열을 씁니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + I/O 오류가 발생하는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + 1 + + + 스트림에 문자열을 씁니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + + 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 + + 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터를 포함하는 문자 배열입니다. + 데이터 읽기를 시작할 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열을 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 줄 종결자를 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 스트림에 쓸 문자입니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 스트림 작성기가 삭제됩니다. + 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. + + + 문자열에서 읽어오는 를 구현합니다. + 2 + + + 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. + + 가 초기화되어야 하는 문자열입니다. + + 매개 변수가 null인 경우 + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. + 현재 판독기가 닫힌 경우 + 2 + + + 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. + 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 버퍼의 시작 인덱스입니다. + 읽을 문자 수입니다. + + 가 null입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. + + 가 null입니다. + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. + 현재 판독기가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 2 + + + 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. + 내부 문자열의 현재 위치에서 끝까지의 내용입니다. + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 현재 판독기가 닫힌 경우 + 2 + + + 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 문자열 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 형식 지정을 제어하는 개체입니다. + + + 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + + 가 null입니다. + + + 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. + 작성할 StringBuilder입니다. + 형식 지정을 제어하는 개체입니다. + + 가 null입니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 출력이 쓰여질 을 가져옵니다. + 출력이 쓰여질 Encoding입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. + 비동기 플러시 작업을 나타내는 작업입니다. + + + 내부 를 반환합니다. + 내부 StringBuilder입니다. + 2 + + + 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. + 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. + 2 + + + 문자를 문자열에 씁니다. + 쓸 문자입니다. + 작성기가 닫힌 경우 + 2 + + + 문자의 하위 배열을 문자열에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 또는 가 음수인 경우 + ( + )> 인 경우Length. + 작성기가 닫힌 경우 + 2 + + + 문자를 현재 문자열에 씁니다. + 쓸 문자열입니다. + 작성기가 닫힌 경우 + 2 + + + 문자를 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자를 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 문자열에 쓸 문자입니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 읽기를 시작하는 버퍼의 위치입니다. + 쓸 최대 문자 수입니다. + + 가 null입니다. + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. + 문자열 작성기가 삭제됩니다. + 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. + + + 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + TextReader에 읽을 데이터를 제공하지 않습니다. + 1 + + + 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. + 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. + 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. + 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. + 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다. + + 가 null인 경우 + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 2 + + + 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. + 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. + 쓰기를 시작할 의 위치입니다. + 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. + + 가 null인 경우 + + 또는 가 음수인 경우 + + 와 의 합계가 버퍼 길이보다 큰 경우 + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. + 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. + I/O 오류가 발생하는 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + + 가 닫힌 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. + 다음 줄의 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. + I/O 오류가 발생하는 경우 + + 가 닫힌 경우 + 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 + 다음 줄의 문자 수가 보다 큰 경우 + 1 + + + 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. + 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. + 문자 수가 보다 큽니다. + 텍스트 판독기가 삭제된 경우 + 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. + + + 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. + 2 + + + + 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 서식 지정을 제어하는 개체입니다. + + + 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. + + + 해당 개체에서 사용하는 리소스를 모두 해제합니다. + + + + 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. + 출력을 쓰는 문자 인코딩입니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 1 + + + 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. + 비동기 플러시 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. + + + 서식 지정을 제어하는 개체를 가져옵니다. + 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. + 2 + + + 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. + 현재 TextWriter의 줄 종결자 문자열입니다. + 2 + + + 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. + 1 + + + Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + + 또는 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 Boolean 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 텍스트 스트림에 쓸 문자입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 데이터를 읽을 문자 배열입니다. + 데이터 읽기를 시작하는 의 문자 위치입니다. + 쓸 최대 문자 수입니다. + 버퍼 길이에서 를 빼면 보다 작은 경우 + + 매개 변수가 null인 경우 + + 또는 가 음수인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 10진수 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 8바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 있는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 4바이트 부동 소수점 값입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. + 1 + + + + 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 첫 번째 개체입니다. + 서식을 지정하고 쓸 두 번째 개체입니다. + 서식을 지정하고 쓸 세 번째 개체입니다. + + 가 null인 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. + 1 + + + + 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. + 합성 형식 문자열입니다(설명 부분 참조). + 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. + 문자열이나 개체가 null로 전달되는 경우 + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + + 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. + 1 + + + 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 4바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. + 쓸 부호 없는 8바이트 정수입니다. + + 가 닫힌 경우 + I/O 오류가 발생하는 경우 + 1 + + + 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자입니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 데이터가 있는 문자 배열입니다. + 데이터 검색을 시작하는 버퍼의 문자 위치입니다. + 쓸 문자 수입니다. + + 가 null인 경우 + + 와 의 합이 버퍼 길이보다 큽니다. + + 또는 가 음수인 경우 + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. + 비동기 쓰기 작업을 나타내는 작업입니다. + 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. + 텍스트 작성기가 삭제됩니다. + 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml new file mode 100644 index 00000000..d9ad6103 --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml @@ -0,0 +1,2023 @@ + + + + System.IO + + + + Считывает примитивные типы данных как двоичные значения в заданной кодировке. + 2 + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Входной поток. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. + Входной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Входной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. + Параметр или имеет значение null. + + + Предоставляет доступ к базовому потоку объекта . + Базовый поток, связанный с объектом BinaryReader. + 2 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. + Количество байтов, чтение которых необходимо выполнить. + Конец потока достигнут раньше, чем было выполнено чтение байтов. + Ошибка ввода-вывода. + Запрошенное значение превышает размер внутреннего буфера. + + + Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. + Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. + Ошибка ввода-вывода. + Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. + 2 + + + Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. + Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Количество байтов, чтение которых необходимо выполнить. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. + Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. + Буфер, в который должны считываться данные. + Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. + Число символов для чтения. + Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число в сжатом формате. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Поток поврежден. + + + Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. + Значение true, если байт не равен нулю; в противном случае — значение false. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. + Следующий байт, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. + Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. + Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Ошибка ввода-вывода. + Поток закрыт. + Значение отрицательно. + 2 + + + Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. + Символ, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + Выполнено чтение символа-заместителя. + 2 + + + Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. + Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. + Количество символов, которое необходимо считать. + Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. + Поток закрыт. + Ошибка ввода-вывода. + Значение отрицательно. + 2 + + + Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. + Десятичное значение, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Число с плавающей запятой длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число со знаком длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. + Целое число со знаком длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. + Байт со знаком, считанный из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Число с плавающей запятой длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. + Считываемая строка. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. + Целое число без знака длиной 2 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. + Целое число без знака длиной 4 байта, считанное из текущего потока. + Достигнут конец потока. + Поток закрыт. + Ошибка ввода-вывода. + 2 + + + Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. + Целое число без знака длиной 8 байт, считанное из текущего потока. + Достигнут конец потока. + Ошибка ввода-вывода. + Поток закрыт. + 2 + + + Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. + 2 + + + Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. + + + Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. + Выходной поток. + Поток не поддерживает запись или был закрыт до начала операции. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. + Выходной поток. + Кодировка символов, которую нужно использовать. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. + Выходной поток. + Кодировка символов, которую нужно использовать. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Поток не поддерживает запись или был закрыт до начала операции. + Значение параметра или — null. + + + Получает базовый поток . + Базовый поток, связанный с объектом BinaryWriter. + 1 + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Задает без резервного хранилища. + 1 + + + Содержит базовый поток. + + + Задает позицию в текущем потоке. + Позиция в текущем потоке. + Смещение в байтах относительно . + Поле указывает точку отсчета, относительно которой указывается новая позиция. + Указатель позиции в файле перемещен в недопустимую позицию. + Значение является недопустимым. + 1 + + + Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. + Записываемое в поток значение типа Boolean (0 или 1). + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. + Записываемый в поток байт без знака. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись массива байтов в базовый поток. + Массив байтов, содержащий записываемые в поток данные. + Ошибка ввода-вывода. + Поток закрыт. + Параметр имеет значение null. + 1 + + + Выполняет запись части массива байтов в текущий поток. + Массив байтов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество записываемых байтов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. + Незаменяющий символ Юникода, который необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + + представляет собой единичный символ-заместитель. + 1 + + + Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. + Массив символов, содержащий записываемые в поток данные. + Параметр имеет значение null. + Поток закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. + Массив символов, содержащий записываемые в поток данные. + Стартовая точка в буфере , с которой начинается запись. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. + Десятичное значение, которое необходимо записать. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число со знаком размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число со знаком размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число со знаком размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. + Байт со знаком, который необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. + Записываемое значение. + Ошибка ввода-вывода. + Параметр имеет значение null. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. + Целое число без знака размером 2 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. + Целое число без знака размером 4 байта, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. + Целое число без знака размером 8 байт, которое необходимо записать в поток. + Ошибка ввода-вывода. + Поток закрыт. + 1 + + + Записывает 32-разрядное целое число в сжатом формате. + 32-разрядное целое число, которое необходимо записать. + Достигнут конец потока. + Поток закрыт. + Поток закрыт. + + + Исключение, которое создается при попытке выполнить чтение за пределами потока. + 2 + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. + + + Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. + Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Исключение возникает, когда поток данных имеет недопустимый формат. + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. + Массив байтов без знака, из которого создается текущий поток. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Свойство имеет значение null. + Значение параметра или меньше нуля. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Свойство имеет значение null. + Параметр или имеет отрицательное значение. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. + Массив байтов без знака, из которого создается данный поток. + Индекс в , с которого начинается поток. + Длина потока в байтах. + Параметр свойства , который определяет возможность поддержки потоком записи. + Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом значения параметра меньше значения параметра . + + + Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. + Исходный размер внутреннего массива в байтах. + Значение отрицательно. + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. + Значение true, если поток открыт. + 2 + + + Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 2 + + + Возвращает или задает число байтов, выделенных для этого потока. + Длина применимой к использованию части буфера для потока. + Заданная емкость отрицательная или меньше текущей длины потока. + Текущий поток закрыт. + set вызывается для потока, емкость которого нельзя изменить. + 2 + + + Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля. + Токен для отслеживания запросов отмены. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Переопределяет метод так, что никакие действия не выполняются. + 2 + + + Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены. + Поток был ликвидирован. + + + Возвращает длину потока в байтах. + Длина потока в байтах. + Поток закрыт. + 2 + + + Возвращает или задает текущее положение в потоке. + Текущее положение в потоке. + В качестве положения задано отрицательное значение или значение, большее . + Поток закрыт. + 2 + + + Считывает блок байтов из текущего потока и записывает данные в буфер. + Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. + При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Длина буфера за вычетом меньше, чем . + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из текущего потока. + Байт приводится к типу или -1, если достигнут конец потока. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для положения в текущем потоке. + Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. + Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. + Значение типа , которое действует как точка ссылки поиска. + Попытка поиска выполняется до начала потока. + Значение больше значения . + + недопустим. -или-Значение вызвало арифметическое переполнение. + Текущий экземпляр потока закрыт. + 2 + + + Задает указанное значение для длины текущего потока. + Значение задаваемой длины. + Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. + Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. + 2 + + + Записывает содержимое потока в массив байтов независимо от свойства . + Новый массив байтов. + 2 + + + Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. + Значение true, если преобразование прошло успешно; в противном случае — значение false. + Сегмент массива байтов, из которого был создан данный поток. + + + Записывает в текущий поток блок байтов, используя данные, считанные из буфера. + Буфер, из которого записываются данные. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. + Длина буфера за вычетом меньше, чем . + Параметр или имеет отрицательное значение. + Ошибка ввода-вывода. + Текущий экземпляр потока закрыт. + 2 + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение текущего потока. + Записываемый байт. + Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. + Текущий поток закрыт. + 2 + + + Записывает все содержимое данного потока памяти в другой поток. + Поток, в который требуется осуществить запись данного потока памяти. + Свойство имеет значение null. + Текущий или конечный поток закрыт. + 2 + + + Задает позицию в потоке, используемую для поиска. + 2 + + + Задает начало потока. + + + Задает текущее положение в потоке. + + + Задает конец потока. + + + Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 2 + + + Инициализирует новый экземпляр класса . + + + При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. + Значение true, если поток поддерживает чтение; в противном случае — значение false. + 1 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. + Значение true, если поток поддерживает поиск; в противном случае — значение false. + 1 + + + Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. + Значение, которое показывает, может ли для данного потока истечь время ожидания. + 2 + + + При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. + Значение true, если поток поддерживает запись; в противном случае — значение false. + 1 + + + Считывает байты из текущего потока и записывает их в другой поток. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Поток, в который будет скопировано содержимое текущего потока. + Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. + Текущий поток или параметр был закрыт до вызова метода . + Произошла ошибка ввода-вывода. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Свойство имеет значение null. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. + Задача, представляющая асинхронную операцию копирования. + Поток, в который будет скопировано содержимое текущего потока. + Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Параметр имеет отрицательное значение или равен нулю. + Текущий поток или поток назначения удаляется. + Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. + + + Освобождает все ресурсы, занятые модулем . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. + Ошибка ввода-вывода. + 2 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию очистки. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Поток был ликвидирован. + + + При переопределении в производном классе получает длину потока в байтах. + Длинное значение, представляющее длину потока в байтах. + Класс, созданный на основе класса Stream, не поддерживает возможность поиска. + Методы были вызваны после закрытия потока. + 1 + + + Объект Stream без резервного хранилища. + 1 + + + При переопределении в производном классе получает или задает позицию в текущем потоке. + Текущее положение в потоке. + Ошибка ввода-вывода. + Этот поток не поддерживает поиск. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. + Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. + Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. + Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. + Максимальное количество байтов, которое должно быть считано из текущего потока. + Сумма значений параметров и больше длины буфера. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 1 + + + Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + Буфер, в который записываются данные. + Смещение байтов в , с которого начинается запись данных из потока. + Максимальное число байтов, предназначенных для чтения. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает чтение. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией чтения. + + + Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. + Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. + Поток не поддерживает чтение. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + При переопределении в производном классе задает позицию в текущем потоке. + Новая позиция в текущем потоке. + Смещение в байтах относительно параметра . + Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. + Ошибка ввода-вывода. + Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 1 + + + При переопределении в производном классе задает длину текущего потока. + Нужная длина текущего потока в байтах. + Ошибка ввода-вывода. + Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. + Методы были вызваны после закрытия потока. + 2 + + + При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. + Массив байтов.Этот метод копирует байты из в текущий поток. + Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. + Количество байтов, которое необходимо записать в текущий поток. + Сумма  и  больше, чем длина буфера. + + — null. + + или  является отрицательным. + Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. + Поток не поддерживает запись. + + был вызван после закрытия потока. + 1 + + + Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. + Задача, представляющая асинхронную операцию записи. + Буфер, из которого записываются данные. + Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. + Максимальное число байтов для записи. + Токен для отслеживания запросов отмены.Значение по умолчанию — . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток не поддерживает запись. + Поток был ликвидирован. + Поток в настоящее время используется предыдущей операцией записи. + + + Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. + Байт, записываемый в поток. + Ошибка ввода-вывода. + Поток не поддерживает запись или был закрыт до начала операции. + Методы были вызваны после закрытия потока. + 2 + + + Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. + Метод всегда создает исключение . + 2 + + + Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. + 1 + + + Инициализирует новый экземпляр класса для заданного потока. + Поток, который нужно считать. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. + Поток, который нужно считать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Свойство имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + + не поддерживает чтение. + Параметр или имеет значение null. + + + Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. + Поток, который нужно считать. + Кодировка символов, которую нужно использовать. + Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. + Минимальный размер буфера. + Поток не поддерживает чтение. + Параметр или имеет значение null. + Значение параметра меньше или равно нулю. + + + Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. + Считываемый поток. + Кодировка символов, которую нужно использовать. + Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. + Минимальный размер буфера. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + + + Возвращает основной поток. + Основной поток. + 2 + + + Возвращает текущую кодировку символов, используемую текущим объектом . + Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. + 2 + + + Очищает внутренний буфер. + 2 + + + Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. + Значение true, если текущее положение находится в конце потока; в противном случае — значение false. + Основной поток удален. + 1 + + + Объект для пустого потока. + 1 + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. + Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. + Ошибка ввода-вывода. + 1 + + + Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. + Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Индекс , с которого требуется начать запись. + Максимальное число считываемых символов. + Длина буфера за вычетом значения параметра меньше значения параметра . + Свойство имеет значение null. + Значение параметра или является отрицательным. + Возникает ошибка ввода-вывода, например закрывается поток. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. + При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Произошла ошибка ввода-вывода. + + + Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. + При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Следующая строка из входного потока или значение null, если достигнут конец входного потока. + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. + Количество символов в следующей строке больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца потока. + Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). + Недостаточно памяти для размещения буфера возвращаемых строк. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. + Количество символов больше . + Поток был ликвидирован. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. + 1 + + + Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Запись в поток запрещена. + + is null. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Значение параметра или — null. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. + Поток, в который требуется выполнить запись. + Кодировка символов, которую нужно использовать. + Размер буфера в байтах. + Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. + Значение параметра или — null. + Значение отрицательно. + Запись в поток запрещена. + + + Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . + Значение true, чтобы заставить сбросить буфер; в противном случае — false. + 1 + + + Получает основной поток, связанный с резервным хранилищем. + Поток, в который StreamWriter выполняет запись. + 2 + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. + 2 + + + Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. + Текущее средство записи закрывается. + Произошла ошибка ввода-вывода. + Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. + 1 + + + Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Поток был ликвидирован. + + + Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает символ в поток. + Символ, записываемый в поток. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток массив символов. + Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток дочерний массив символов. + Массив символов, содержащий записываемые данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Ошибка ввода-вывода. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + 1 + + + Записывает в поток строку. + Строка, записываемая в поток.Если равняется null, запись не выполняется. + + имеет значение True, или буфер полон, и текущее средство записи закрывается. + + имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает символ в поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, содержащий записываемые данные. + Положение символа в буфере с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает строку в поток. + Задача, представляющая асинхронную операцию записи. + Строка, записываемая в поток.Если имеет значение null, запись не выполняется. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток признак конца строки. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в поток. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + + is null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи потока. + Средство записи потока в настоящее время используется предыдущей операцией записи. + + + Реализует класс , осуществляющий чтение из строки. + 2 + + + Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. + Строка, для которой должен быть инициализирован класс . + Значение параметра — null. + + + Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Возвращает следующий доступный символ, но не использует его. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. + Текущее средство чтения закрыто. + 2 + + + Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. + Следующий символ из основной строки или значение -1, если больше нет доступных символов. + Текущее средство чтения закрыто. + 2 + + + Считывает блок символов из строки ввода и увеличивает позицию символов на . + Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Начальный индекс в буфере. + Количество символов, которые необходимо считать. + Параметр имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. + Параметр имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Следующая строка из текущей строки, или значение null, если достигнут конец строки. + Текущее средство чтения закрыто. + Недостаточно памяти для размещения буфера возвращаемых строк. + 2 + + + Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Содержимое, начиная от текущей позиции до конца основной строки. + Недостаточно памяти для размещения буфера возвращаемых строк. + Текущее средство чтения закрыто. + 2 + + + Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. + Количество символов больше . + Удалено средство чтения строки. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Реализует для записи данных в строку.Данные хранятся в основном . + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса с указанным форматом объекта. + Объект , управляющий форматированием. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . + Класс StringBuilder, в который осуществляется запись. + Параметр имеет значение null. + + + Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. + Класс StringBuilder, в который осуществляется запись. + Объект , управляющий форматированием. + Параметр имеет значение null. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. + + + Получает кодировку , в которой осуществляется запись выходных данных. + Encoding, в которой осуществляется запись выходных данных. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + + + Возвращает основной . + Базовый StringBuilder. + 2 + + + Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. + Строка, содержащая символы, записанные в текущий StringWriter. + 2 + + + Записывает символ в строку. + Символ для записи. + Средство записи закрыто. + 2 + + + Записывает в строку дочерний массив символов. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Значение параметра или является отрицательным. + ( + )> .Length. + Средство записи закрыто. + 2 + + + Записывает строку в текущую строку. + Строка для записи. + Средство записи закрыто. + 2 + + + Выполняет асинхронную запись символа в строку. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в строку. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текущую строку. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в строку символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в строку. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение в буфере, с которого начинается чтение данных. + Наибольшее количество символов для записи. + Параметр имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак завершения строки. + Удалено средство записи строки. + Средство записи строки в настоящее время используется предыдущей операцией записи. + + + Представляет средство чтения, позволяющее считывать последовательные наборы символов. + 2 + + + Инициализирует новый экземпляр класса . + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Предоставляет TextReader без данных, доступных для чтения. + 1 + + + Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. + Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. + Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. + Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. + При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов. + Свойство имеет значение null. + Длина буфера за вычетом значения параметра меньше значения параметра . + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 2 + + + Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. + При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. + Позиция в буфере , с которого начинается запись. + Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. + Свойство имеет значение null. + Значение параметра или является отрицательным. + Сумма значений параметров и больше длины буфера. + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. + Следующая строка из средства чтения, или значение null, если все символы считаны. + Ошибка ввода-вывода. + Недостаточно памяти для размещения буфера возвращаемых строк. + Объект закрыт. + Количество символов в следующей строке больше . + 1 + + + Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. + Количество символов в следующей строке больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. + Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. + Ошибка ввода-вывода. + Объект закрыт. + Недостаточно памяти для размещения буфера возвращаемых строк. + Количество символов в следующей строке больше . + 1 + + + Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. + Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. + Количество символов больше . + Удалено средство чтения текста. + Средство чтения в настоящее время используется предыдущей операцией чтения. + + + Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. + 2 + + + Инициализирует новый экземпляр класса . + + + Инициализирует новый экземпляр класса указанным поставщиком формата. + Объект , управляющий форматированием. + + + Сохраняет символы новой строки, используемые для данного TextWriter. + + + Освобождает все ресурсы, используемые объектом . + + + Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. + Кодировка символов, в которой осуществляется запись выходных данных. + 1 + + + Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. + 1 + + + Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. + Задача, представляющая асинхронную операцию очистки. + Удалено средство записи текста. + Средство записи в настоящее время используется предыдущей операцией записи. + + + Возвращает объект, управляющий форматированием. + Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. + 2 + + + Возвращает или задает признак конца строки, используемой текущим TextWriter. + Признак конца строки для текущего TextWriter. + 2 + + + Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись символа в текстовую строку или поток. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет запись массива символов в текстовую строку или поток. + Массив символов, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает дочерний массив символов в текстовую строку или поток. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает текстовое представление десятичного значения в текстовую строку или поток. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. + Записываемый объект. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает строку в текстовую строку или поток. + Строка для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Параметр или имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Выполняет асинхронную запись символа в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись массива символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает дочерний массив символов в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Выполняет асинхронную запись строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Записывает признак конца строки в текстовую строку или поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. + Значение Boolean для записи. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Символ, записываемый в текстовый поток. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Массив символов, из которого считываются данные. + Положение символа в , с которого начинается чтение данных. + Наибольшее количество символов для записи. + Длина буфера за вычетом значения параметра меньше значения параметра . + Параметр имеет значение null. + Значение параметра или является отрицательным. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. + Десятичное значение, которое необходимо записать. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. + Записываемое целое число со знаком размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. + Записываемое целое число со знаком размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. + Записываемый объект.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. + Записываемое значение с плавающей запятой размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток строку, за которой следует признак конца строки. + Строка для записи.Если имеет значение null, записывается только признак конца строки. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). + 1 + + + Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Первый объект для форматирования и записи. + Второй объект для форматирования и записи. + Третий объект для форматирования и записи. + Свойство имеет значение null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). + 1 + + + Записывает отформатированную строку и новую строку, используя ту же семантику, что и . + Строка составного формата (см. примечания). + Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. + Строка или объект передаются в виде null. + Объект закрыт. + Ошибка ввода-вывода. + Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. + Записываемое целое число без знака размером 4 байта. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. + Записываемое целое число без знака размером 8 байт. + Объект закрыт. + Ошибка ввода-вывода. + 1 + + + Асинхронно записывает признак конца строки в текстовую строку или поток. + Задача, представляющая асинхронную операцию записи. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Символ, записываемый в текстовый поток. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. + Задача, представляющая асинхронную операцию записи. + Массив символов, из которого записываются данные. + Положение символа в буфере, с которого начинается извлечение данных. + Количество символов для записи. + Свойство имеет значение null. + Сумма значений параметров и превышает длину буфера. + Значение параметра или является отрицательным. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. + Задача, представляющая асинхронную операцию записи. + Строка для записи.Если значение равно null, записывается только знак конца строки. + Удалено средство записи текста. + Средство записи текста в настоящее время используется предыдущей операцией записи. + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml new file mode 100644 index 00000000..cf7eb52f --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml @@ -0,0 +1,2237 @@ + + + + System.IO + + + + 用特定的编码将基元数据类型读作二进制值。 + 2 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输入流。 + 该流不支持读取，为null 或已关闭。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输入流。 + 要使用的字符编码。 + 该流不支持读取，为null 或已关闭。 + + 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输入流。 + 要使用的字符编码。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + 该流不支持读取，为null 或已关闭。 + + 或 为 null。 + + + 公开对 的基础流的访问。 + 与 BinaryReader 关联的基础流。 + 2 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 用从流中读取的指定字节数填充内部缓冲区。 + 要读取的字节数。 + 在可以读取 之前到达了流的末尾。 + 发生 I/O 错误。 + 请求的 大于内部缓冲区大小。 + + + 返回下一个可用的字符，并且不提升字节或字符的位置。 + 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 + 发生 I/O 错误。 + 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 + 2 + + + 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 输入流中的下一个字符，如果当前无可用字符则为 -1。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 从字节数组中的指定点开始，从流中读取指定的字节数。 + 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字节数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从字符数组中的指定点开始，从流中读取指定的字符数。 + 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 + 将数据读入的缓冲区。 + 缓冲区中的起始点，在该处开始读入缓冲区。 + 要读取的字符数。 + 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + + 为 null。 + + 或 为负。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 以压缩格式读入 32 位整数。 + 压缩格式的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 流已损坏。 + + + 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 + 如果字节为非零，则为 true，否则为 false。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的下一个字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 + 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 发生 I/O 错误。 + 流已关闭。 + + 为负数。 + 2 + + + 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 + 从当前流中读取的字符。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 读取了一个代理项字符。 + 2 + + + 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 + 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 + 要读取的字符数。 + 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 + 流已关闭。 + 发生 I/O 错误。 + + 为负数。 + 2 + + + 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 + 从当前流中读取的十进制数值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 2 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 + 从当前流中读取的 8 字节有符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 + 从当前流中读取的一个有符号字节。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 + 从当前流中读取的 4 字节浮点值。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 + 正被读取的字符串。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 + 从该流中读取的 2 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 + 从该流中读取的 4 字节无符号整数。 + 已到达流的末尾。 + 流已关闭。 + 发生 I/O 错误。 + 2 + + + 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 + 从该流中读取的 8 字节无符号整数。 + 已到达流的末尾。 + 发生 I/O 错误。 + 流已关闭。 + 2 + + + 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 + 2 + + + 初始化向流中写入的 类的新实例。 + + + 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 + 输出流。 + 该流不支持写入或者该流已关闭。 + + 为 null。 + + + 基于所指定的流和特定的字符编码，初始化 类的新实例。 + 输出流。 + 要使用的字符编码。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 + 输出流。 + 要使用的字符编码。 + 如果在释放 对象之后打开流对象，则为 true；否则为， false。 + 该流不支持写入或者该流已关闭。 + + 或 为 null。 + + + 获取 的基础流。 + 与 BinaryWriter 关联的基础流。 + 1 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 指定无后备存储区的 。 + 1 + + + 持有基础流。 + + + 设置当前流中的位置。 + 包含当前流的位置。 + 相对于 的字节偏移量。 + + 的一个字段，指示获取新位置所依据的参考点。 + 文件指针被移到无效位置。 + + 值无效。 + 1 + + + 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 + 要写入的 Boolean 值（0 或 1）。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的无符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将字节数组写入基础流。 + 包含要写入的数据的字节数组。 + 发生 I/O 错误。 + 流已关闭。 + + 为 null。 + 1 + + + 将字节数组部分写入当前流。 + 包含要写入的数据的字节数组。 + + 中开始写入的起始点。 + 要写入的字节数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 要写入的非代理项 Unicode 字符。 + 发生 I/O 错误。 + 流已关闭。 + + 是单一代理项字符。 + 1 + + + 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 为 null。 + 流已关闭。 + 发生 I/O 错误。 + 1 + + + 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 + 包含要写入的数据的字符数组。 + + 中开始写入的起始点。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个十进制值写入当前流，并将流位置提升十六个字节。 + 要写入的十进制值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节有符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 + 要写入的有符号字节。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节浮点值。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 + 要写入的值。 + 发生 I/O 错误。 + + 为 null。 + 流已关闭。 + 1 + + + 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 + 要写入的 2 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 + 要写入的 4 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 + 要写入的 8 字节无符号整数。 + 发生 I/O 错误。 + 流已关闭。 + 1 + + + 以压缩格式写出 32 位整数。 + 要写出的 32 位整数。 + 已到达流的末尾。 + 流已关闭。 + 流已关闭。 + + + 读操作试图超出流的末尾时引发的异常。 + 2 + + + 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + + + 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 在数据流的格式无效时引发的异常。 + + + 初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 用对作为此异常原因的内部异常的引用初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化为零的可扩展容量初始化 类的新实例。 + + + 基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建当前流的无符号字节数组。 + + 为 null。 + + + 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + + 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 为 null。 + + 或 小于零。 + 缓冲区长度减去 小于 。 + + + 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 + 从中创建此流的无符号字节的数组。 + + 内的索引，流从此处开始。 + 流的长度（以字节为单位）。 + + 属性的设置，确定该流是否支持写入。 + 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 小于 。 + + + 使用按指定要求初始化的可扩展容量初始化 类的新实例。 + 内部数组的初始大小（以字节为单位）。 + + 为负数。 + + + 获取一个值，该值指示当前流是否支持读取。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持查找。 + 如果流是打开的，则为 true。 + 2 + + + 获取一个值，该值指示当前流是否支持写入。 + 如果流支持写入，则为 true；否则为 false。 + 2 + + + 获取或设置分配给该流的字节数。 + 流的缓冲区的可使用部分的长度。 + 容量设置为负或小于流的当前长度。 + 当前流已关闭。 + 对不能修改其容量的流调用 set。 + 2 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。 + 要监视取消请求的标记。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放 类使用的非托管资源，并可以选择释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 重写 方法以便不执行任何操作。 + 2 + + + 异步清除此流的所有缓冲区，并监视取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。 + 流已被释放。 + + + 获取流的长度（以字节为单位）。 + 流的长度（以字节为单位）。 + 流已关闭。 + 2 + + + 获取或设置流中的当前位置。 + 流中的当前位置。 + 此位置设置为负值或大于 的值。 + 流已关闭。 + 2 + + + 从当前流中读取字节块并将数据写入缓冲区。 + 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 + 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 + + 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + 缓冲区长度减去 的结果小于 。 + 当前流实例已关闭。 + 2 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流中读取一个字节。 + 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 + 当前流实例已关闭。 + 2 + + + 将当前流中的位置设置为指定值。 + 流内的新位置，通过将初始引用点和偏移量合并计算而得。 + 流内的新位置。它是相对于 参数的位置，而且可正可负。 + 类型 的值，它用作查找引用点。 + 试图在流的开始位置之前查找。 + + 大于 。 + + 无效。- 或 - 导致算法溢出。 + 当前流实例已关闭。 + 2 + + + 将当前流的长度设为指定值。 + 用于设置长度的值。 + 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 + + 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 + 2 + + + 将流内容写入字节数组，而与 属性无关。 + 新的字节数组。 + 2 + + + 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 + 如果转换成功，则为 true；否则为 false。 + 用于创建此流的字节数组段。 + + + 使用从缓冲区读取的数据将字节块写入当前流。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 最多写入的字节数。 + + 为 null。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 + 缓冲区长度减去 的结果小于 。 + + 或 为负。 + 发生 I/O 错误。 + 当前流实例已关闭。 + 2 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入当前位置上的当前流。 + 要写入的字节。 + 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 + 当前流已关闭。 + 2 + + + 将此内存流的整个内容写入到另一个流中。 + 要写入此内存流的流。 + + 为 null。 + 当前流或目标流已关闭。 + 2 + + + 指定在流的位置以查找使用。 + 2 + + + 指定流的开头。 + + + 指定流内的当前位置。 + + + 指定流的结尾。 + + + 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 类的新实例。 + + + 当在派生类中重写时，获取指示当前流是否支持读取的值。 + 如果流支持读取，为 true；否则为 false。 + 1 + + + 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 + 如果流支持查找，为 true；否则为 false。 + 1 + + + 获取一个值，该值确定当前流是否可以超时。 + 一个确定当前流是否可以超时的值。 + 2 + + + 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 + 如果流支持写入，则为 true；否则为 false。 + 1 + + + 从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 + 当前流的内容将复制到的流。 + 缓冲区的大小。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流不支持读取。- 或 - 不支持写入。 + 在调用 方法前当前流或 已关闭。 + 发生了 I/O 错误。 + + + 从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + + 为 null。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 + 表示异步复制操作的任务。 + 当前流的内容将复制到的流。 + 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 为负数或零。 + 当前流或目标流已释放。 + 当前流不支持阅读，或目标流不支持写入。 + + + 释放由 使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 + 发生 I/O 错误。 + 2 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 + 表示异步刷新操作的任务。 + 要监视取消请求的标记。默认值为 。 + 流已被释放。 + + + 当在派生类中重写时，获取流长度（以字节为单位）。 + 表示流长度（以字节为单位）的长值。 + 从 Stream 派生的类不支持查找。 + 在流关闭后调用方法。 + 1 + + + 无后备存储区的 Stream。 + 1 + + + 当在派生类中重写时，获取或设置当前流中的位置。 + 流中的当前位置。 + 发生 I/O 错误。 + 流不支持查找。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 + 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 + 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 + + 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 + 要从当前流中最多读取的字节数。 + + 与 的和大于缓冲区长度。 + + 为 null。 + + 或 为负。 + 发生 I/O 错误。 + 流不支持读取。 + 在流关闭后调用方法。 + 1 + + + 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 数据写入的缓冲区。 + + 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 + 最多读取的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持读取。 + 流已被释放。 + 该流正在由其前一次读取操作使用。 + + + 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 + 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 + 流不支持读取。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 + 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 当在派生类中重写时，设置当前流中的位置。 + 当前流中的新位置。 + 相对于 参数的字节偏移量。 + + 类型的值，指示用于获取新位置的参考点。 + 发生 I/O 错误。 + 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 1 + + + 当在派生类中重写时，设置当前流的长度。 + 所需的当前流的长度（以字节表示）。 + 发生 I/O 错误。 + 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 + 在流关闭后调用方法。 + 2 + + + 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 + 字节数组。此方法将 个字节从 复制到当前流。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 + 要写入当前流的字节数。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 流不支持写入。 + + 流关闭后调用。 + 1 + + + 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 + 表示异步写入操作的任务。 + 从中写入数据的缓冲区。 + + 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 + 最多写入的字节数。 + 要监视取消请求的标记。默认值为 。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流不支持写入。 + 流已被释放。 + 该流正在由其前一次写入操作使用。 + + + 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 + 要写入流中的字节。 + 发生 I/O 错误。 + 该流不支持写入，或者该流已关闭。 + 在流关闭后调用方法。 + 2 + + + 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 + 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 + + 方法总是引发 。 + 2 + + + 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 为指定的流初始化 类的新实例。 + 要读取的流。 + + 不支持读取。 + + 为 null。 + + + 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 + 要读取的流。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 为 null。 + + + 用指定的字符编码为指定的流初始化 类的一个新实例。 + 要读取的流。 + 要使用的字符编码。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + + 不支持读取。 + + 或 为 null。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 + 要读取的流。 + 要使用的字符编码。 + 指示是否在文件头查找字节顺序标记。 + 最小缓冲区大小。 + 流不支持读取。 + + 或 为 null。 + + 小于或等于零。 + + + 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 + 要读取的流。 + 要使用的字符编码。 + 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 + 最小缓冲区大小。 + 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 + + + 返回基础流。 + 基础流。 + 2 + + + 获取当前 对象正在使用的当前字符编码。 + 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 + 2 + + + 清除内部缓冲区。 + 2 + + + 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 获取一个值，该值指示当前的流位置是否在流结尾。 + 如果当前流位置位于流的末尾，则为 true；否则为 false。 + 基础流已释放。 + 1 + + + 空流周围的 。 + 1 + + + 返回下一个可用字符，但不使用它。 + 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 + 发生 I/O 错误。 + 1 + + + 读取输入流中的下一个字符并使该字符位置提升一个字符。 + 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 + 发生 I/O 错误。 + 1 + + + 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 + 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 开始写入的 的索引。 + 要读取的最大字符数。 + 缓冲区长度减去 小于 。 + + 为 null。 + + 或 为负。 + 出现 I/O 错误，如流被关闭。 + 1 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 + 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生了 I/O 错误。 + + + 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前流中读取一行字符并将数据作为字符串返回。 + 输入流中的下一行；如果到达了输入流的末尾，则为 null。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 从当前流中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 + 下一行中的字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取来自流的当前位置到结尾的所有字符。 + 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 + 内存不足，无法为返回的字符串分配缓冲区。 + 发生 I/O 错误。 + 1 + + + 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 + 字符数大于 。 + 流已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 + 1 + + + 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 + 要写入的流。 + + 不可写。 + + 为 null。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + + 或 为 null。 + + 不可写。 + + + 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 + 要写入的流。 + 要使用的字符编码。 + 缓冲区大小（以字节为单位）。 + true to leave the stream open after the object is disposed; otherwise, false. + + 或 为 null。 + + 为负数。 + + 不可写。 + + + 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 + 强制 刷新其缓冲区时，为 true；否则，为 false。 + 1 + + + 获取同后备存储连接的基础流。 + 此 StreamWriter 正在写入的基础流。 + 2 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + 当前编码不支持显示半个 Unicode 代理项对。 + + + 获取将输出写入到其中的 。 + 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 + 2 + + + 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 + 当前编写器已关闭。 + 出现 I/O 错误。 + 当前编码不支持显示半个 Unicode 代理项对。 + 1 + + + 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 + 表示异步刷新操作的任务。 + 流已被释放。 + + + 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将字符写入流。 + 要写入流中的字符。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符数组写入流。 + 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符的子数组写入流。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 发生 I/O 错误。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 1 + + + 将字符串写入流。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + + 为 true 或 缓冲区已满，并且当前编写器已关闭。 + + 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 + 发生 I/O 错误。 + 1 + + + 将字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 包含要写入的数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入流的字符串。如果 为 null，则不写入任何内容。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将行终止符异步写入该流。 + 表示异步写操作的任务。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符异步写入该流。 + 表示异步写操作的任务。 + 要写入流中的字符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符的子数组异步写入该流。 + 表示异步写操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据时缓冲区中的字符位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 将后跟行终止符的字符串异步写入该流。 + 表示异步写操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 流编写器已被释放。 + 流编写器正在由其前一次写入操作使用。 + + + 实现从字符串进行读取的 。 + 2 + + + 初始化从指定字符串进行读取的 类的新实例。 + 应将 初始化为的字符串。 + + 参数为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 返回下一个可用的字符，但不使用它。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 + 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 + 当前读取器已关闭。 + 2 + + + 读取输入字符串中的字符块，并将字符位置提升 。 + 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 缓存区中的起始索引。 + 要读取的字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + 当前读取器已关闭。 + 2 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前字符串中读取一行字符并将数据作为字符串返回。 + 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 + 当前读取器已关闭。 + 内存不足，无法为返回的字符串分配缓冲区。 + 2 + + + 从当前字符串中异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 从当前位置到基础字符串的结尾之间的内容。 + 内存不足，无法为返回的字符串分配缓冲区。 + 当前读取器已关闭。 + 2 + + + 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 + 字符数大于 。 + 字符串读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式控制初始化 类的新实例。 + 控制格式设置的 对象。 + + + 初始化写入指定 的 类的新实例。 + 要写入的 StringBuilder。 + + 为 null。 + + + 初始化写入指定 并具有指定格式提供程序的 类的新实例。 + 要写入的 StringBuilder。 + 控制格式设置的 对象。 + + 为 null。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 + + + 获取将输出写入到其中的 。 + 用来写入输出的 Encoding。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + + + 返回基础 。 + 基础 StringBuilder。 + 2 + + + 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 + 包含写入到当前 StringWriter 中的字符的字符串。 + 2 + + + 将字符写入该字符串。 + 要写入的字符。 + 编写器已关闭。 + 2 + + + 将字符的子数组写入该字符串。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + 或 为负。 + ( + )> 。Length. + 编写器已关闭。 + 2 + + + 将字符串写入当前流。 + 要写入的字符串。 + 编写器已关闭。 + 2 + + + 以异步方式将字符写入流。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将字符串写入当前流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 以异步方式将后跟行结束符的字符写入该字符串。 + 表示异步写入操作的任务。 + 要写入字符串中的字符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入该字符串。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始读取数据缓存中的位置。 + 要写入的最大字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 将一后跟行结束符的字符串异步写入当前字符串。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 字符串编写器已被释放。 + 字符串编写器正在由其前一次写操作使用。 + + + 表示可读取有序字符系列的读取器。 + 2 + + + 初始化 类的新实例。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + 提供一个无数据可供读取的 TextReader。 + 1 + + + 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 + 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 + 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 + 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 + 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 + 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。 + + 为 null。 + 缓冲区长度减去 小于 。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 2 + + + 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 + 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 + 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 + 在 中开始写入的位置。 + 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 + + 为 null。 + + 或 为负。 + + 与 的和大于缓冲区长度。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 从文本读取器中读取一行字符并将数据作为字符串返回。 + 读取器中的下一行，或为 null （如果已读取了所有字符）。 + 发生 I/O 错误。 + 内存不足，无法为返回的字符串分配缓冲区。 + + 是关闭的。 + 下一行中的字符数大于 + 1 + + + 异步读取一行字符并将数据作为字符串返回。 + 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 + 下一行中的字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 + 发生 I/O 错误。 + + 是关闭的。 + 内存不足，无法为返回的字符串分配缓冲区。 + 下一行中的字符数大于 + 1 + + + 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 + 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 + 字符数大于 。 + 文本读取器已被释放。 + 编写器正在由其前一次读取操作使用。 + + + 表示可以编写一个有序字符系列的编写器。此类为抽象类。 + 2 + + + 初始化 类的新实例。 + + + 使用指定的格式提供程序初始化 类的新实例。 + 控制格式设置的 对象。 + + + 存储用于此 TextWriter 的换行符。 + + + 释放由 对象使用的所有资源。 + + + 释放由 占用的非托管资源，还可以释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 当在派生类中重写时，返回用来写输出的该字符编码。 + 用来写入输出的字符编码。 + 1 + + + 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 1 + + + 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 + 表示异步刷新操作的任务。 + 文本编写器已被释放。 + 编写器正在由其前一次写操作使用。 + + + 获取控制格式设置的对象。 + 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 + 2 + + + 获取或设置由当前 TextWriter 使用的行结束符字符串。 + 当前 TextWriter 的行结束符字符串。 + 2 + + + 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 + 1 + + + 将 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符写入该文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符数组写入该文本字符串或流。 + 要写入文本流中的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将字符的子数组写入文本字符串或流。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符串写入到文本字符串或流。 + 要写入的字符串。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + + 或 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 以异步形式将字符写入到下一个文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符数组写入到下一个字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将字符的子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 以异步形式将字符串写入到下一字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将行结束符的字符串写入文本字符串或流。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 + 要写入的 Boolean 值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符写入文本字符串或流。 + 要写入文本流中的字符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符数组写入文本字符串或流。 + 从其读取数据的字符数组。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符子数组写入文本字符串或流。 + 从其读取数据的字符数组。 + 在开始读取数据时 中的字符位置。 + 要写入的最大字符数。 + 缓冲区长度减去 小于 。 + + 参数为 null。 + + 或 为负。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 + 要写入的十进制值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 8 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节有符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 + 要写入的对象。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 + 要写入的 4 字节浮点值。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的字符串写入文本字符串或流。 + 要写入的字符串。如果 为 null，则只写入行终止符。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 + 1 + + + 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 要格式化和写入的第一个对象。 + 要格式化和写入的第二个对象。 + 要设置格式和写入的第三个对象。 + + 为 null。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 + 1 + + + 使用与 相同的语义写出格式化的字符串和一个新行。 + 复合格式字符串（请参见“备注”）。 + 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 + 字符串或对象作为 null 传入。 + + 是关闭的。 + 发生 I/O 错误。 + + 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 + 1 + + + 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 4 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 + 要写入的 8 字节无符号整数。 + + 是关闭的。 + 发生 I/O 错误。 + 1 + + + 将行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符子数组异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要从中写出数据的字符数组。 + 在开始接收数据时缓存中的字符位置。 + 要写入的字符数。 + + 为 null。 + + plus 大于缓冲区长度。 + + 或 为负。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + 将后跟行结束符的字符串异步写入文本字符串或流。 + 表示异步写入操作的任务。 + 要写入的字符串。如果值为 null，则只写入行终止符。 + 文本编写器已被释放。 + 文本编写器正在由其前一次写操作使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml new file mode 100644 index 00000000..26192a9d --- /dev/null +++ b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml @@ -0,0 +1,2246 @@ + + + + System.IO + + + + 以特定的編碼方式，將基本資料型別當做二進位值讀取。 + 2 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸入資料流。 + 資料流不支援讀取，為 null，或已經關閉。 + + + 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 + 輸入資料流。 + 要使用的字元編碼。 + 資料流不支援讀取，為 null，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 + 輸入資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + 資料流不支援讀取，為 null，或已經關閉。 + + 或 為 null。 + + + 公開 之基礎資料流的存取。 + 與 BinaryReader 相關聯的基礎資料流。 + 2 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 將從資料流讀取的指定位元組數目填入內部緩衝區。 + 要讀取的位元組數。 + 在 可讀取之前到達資料流末端。 + 發生 I/O 錯誤。 + 所要求的 大於內部緩衝區大小。 + + + 傳回下一個可用字元，而不前移位元組或字元的位置。 + 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 + 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 + 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的位元組數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 由字元陣列中的指定點開始，從資料流讀取指定字元數。 + 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 + 要讀取資料的緩衝區。 + 開始讀取資料到緩衝區的緩衝區起始點。 + 要讀取的字元數。 + 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + + 為 null。 + + 或 為負值。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以壓縮格式讀取 32 位元整數。 + 壓縮格式的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 資料流已損毀。 + + + 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 + 如果位元組為非零值，則為 true；否則為 false。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 + 自目前資料流讀取的下一個位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 + 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 + 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為負值。 + 2 + + + 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 + 自目前資料流讀取的字元。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 讀取到 Surrogate 字元 + 2 + + + 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 + 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 + 要讀取的字元數。 + 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 + 已關閉資料流。 + 發生 I/O 錯誤。 + + 為負值。 + 2 + + + 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 + 自目前資料流讀取的十進位值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自目前資料流讀取的 2 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自目前資料流讀取的 8 位元組帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 + 自資料流讀取的帶正負號的位元組。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 + 自目前資料流讀取的 4 位元組浮點數值。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 + 讀取的字串。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 + 自這個資料流讀取 2 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 + 自這個資料流讀取 4 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 2 + + + 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 + 自這個資料流讀取 8 位元組不帶正負號的整數。 + 已到達資料流的末端。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 2 + + + 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 + 2 + + + 初始化 類別的新執行個體，其將寫入資料流。 + + + 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 資料流不支援寫入，或已經關閉。 + + 為 null。 + + + 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 + 輸出資料流。 + 要使用的字元編碼。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 輸出資料流。 + 要使用的字元編碼。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + 資料流不支援寫入，或已經關閉。 + + 或 是 null。 + + + 取得 的基礎資料流。 + 與 BinaryWriter 相關聯的基礎資料流。 + 1 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 指定沒有備份存放區的 。 + 1 + + + 容納基礎資料流。 + + + 設定目前資料流位置。 + 目前資料流的位置。 + 相對於 的位元組位移。 + + 的欄位，表示要取得新位置的參考點。 + 檔案指標已移至無效的位置。 + + 值是無效的。 + 1 + + + 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 + 要寫入的 Boolean 值 (0 或 1)。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的不帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將位元組陣列寫入基礎資料流。 + 含有要寫入之資料的位元組陣列。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 為 null。 + 1 + + + 將一個區域的位元組陣列寫入目前資料流。 + 含有要寫入之資料的位元組陣列。 + + 中要開始寫入的起始點。 + 要寫入的位元組數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 非 Surrogate，要寫入的 Unicode 字元。 + 發生 I/O 錯誤。 + 已關閉資料流。 + + 是單一 Surrogate 字元。 + 1 + + + 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 為 null。 + 已關閉資料流。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 + 含有要寫入之資料的字元陣列。 + + 中要開始寫入的起始點。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 + 要寫入的十進位值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 + 要寫入的帶正負號位元組。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組浮點數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 + 要寫入的值。 + 發生 I/O 錯誤。 + + 為 null。 + 已關閉資料流。 + 1 + + + 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 + 要寫入的二位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 + 要寫入的四位元組不帶正負號的整數。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 + 要寫入的八位元組不帶正負號的整數值。 + 發生 I/O 錯誤。 + 已關閉資料流。 + 1 + + + 以壓縮格式寫入 32 位元整數。 + 要寫入的 32 位元整數。 + 已到達資料流的末端。 + 已關閉資料流。 + 已關閉資料流。 + + + 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 + 2 + + + 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + + + 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 資料流在格式無效時擲回的例外狀況。 + + + 初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 + + + 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 + 用於建立目前資料流之不帶正負號位元組的陣列。 + + 為 null。 + + + 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + + 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 為 null。 + + 或 小於零。 + 緩衝區長度減去 小於 。 + + + 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 + 用於建立這個資料流之不帶正負號位元組的陣列。 + + 中資料流開始處的索引。 + 資料流的長度，以位元組為單位。 + + 屬性的設定，決定資料流是否支援寫入。 + 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 + + 為 null。 + + 或 為負值。 + 緩衝區長度減去 小於 。 + + + 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 + 內部陣列的初始大小，以位元組為單位。 + + 為負值。 + + + 取得表示目前資料流是否支援讀取的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援搜尋的值。 + true，如果資料流已開啟。 + 2 + + + 取得表示目前資料流是否支援寫入的值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 2 + + + 取得或設定配置給這個資料流的位元組數目。 + 資料流緩衝區可使用部分的長度。 + 設定的容量為負數或小於資料流目前的長度。 + 目前的資料流已經關閉。 + set 在無法修改其容量的資料流上被叫用 (Invoke)。 + 2 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 + 用來監視是否有取消要求的語彙基元。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 覆寫 方法，以便不執行任何動作。 + 2 + + + 非同步清除這個資料流的所有緩衝區，並監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。 + 已處置資料流。 + + + 取得資料流的長度，以位元組為單位。 + 資料流的長度，以位元組為單位。 + 已關閉資料流。 + 2 + + + 取得或設定資料流中目前的位置。 + 在資料流的目前位置。 + 位置設為負數值或大於 的值。 + 已關閉資料流。 + 2 + + + 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 + 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 + + 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + 緩衝區的長度減去 小於 。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從目前的資料流讀取位元組。 + 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流中的位置設定為指定的數值。 + 資料流中的新位置，是組合初始的參考點和位移計算出來的。 + 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 + + 類型的值，做為搜尋參考點。 + 在資料流開頭之前嘗試搜尋。 + + 大於 。 + 有無效的 。-或- 造成了算術溢位。 + 目前的資料流執行個體已關閉。 + 2 + + + 將目前資料流的長度設定為指定的數值。 + 要設定長度的數值。 + 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 + + 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 + 2 + + + 不論 屬性為何，將資料流內容寫入位元組陣列。 + 新的位元組陣列。 + 2 + + + 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 + 如果轉換成功，則為 true；否則為 false。 + 從其中建立此資料流的位元組陣列區段。 + + + 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入的最大位元組數。 + + 為 null。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 + 緩衝區的長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + 目前的資料流執行個體已關閉。 + 2 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入位元組至資料流目前位置。 + 要寫入的位元組。 + 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 + 目前的資料流已經關閉。 + 2 + + + 將這個記憶體資料流的整個內容寫入另一個資料流。 + 要寫入這個記憶體資料流的資料流。 + + 為 null。 + 目前的資料流或目標資料流已經關閉。 + 2 + + + 指定資料流中要用於搜尋的位置。 + 2 + + + 指定資料流的開端。 + + + 指定資料流中的目前位置。 + + + 指定資料流的末端。 + + + 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 2 + + + 初始化 類別的新執行個體。 + + + 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 + 如果資料流支援讀取，則為 true；否則為 false。 + 1 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 + 如果資料流支援搜尋，則為 true；否則為 false。 + 1 + + + 取得值，該值判斷目前的資料流是否可以逾時。 + 值，判斷目前的資料流是否可以逾時。 + 2 + + + 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 + 如果資料流支援寫入，則為 true；否則，為 false。 + 1 + + + 從目前資料流讀取位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流不支援讀取。-或- 不支援寫入。 + 目前資料流或 已經在呼叫 方法之前關閉。 + 發生 I/O 錯誤。 + + + 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + + 為 null。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 + 表示非同步複製作業的工作。 + 目前資料流的內容將複製到其中的資料流。 + 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 為負值或零。 + 目前資料流或目的資料流已處置。 + 目前資料流不支援讀取，或目的資料流不支援寫入。 + + + 釋放 所使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 發生 I/O 錯誤。 + 2 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 已處置資料流。 + + + 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 + 表示非同步排清作業的工作。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + 已處置資料流。 + + + 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 + 代表資料流長度的長數值 (以位元組為單位)。 + 衍生自 Stream 的類別不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 沒有底層存放區的 Stream。 + 1 + + + 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 + 在資料流的目前位置。 + 發生 I/O 錯誤。 + 資料流不支援搜尋。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 + 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 + 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 + + 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 + 自目前資料流讀取的最大位元組數。 + + 和 的總和大於緩衝區的長度。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 寫入資料的緩衝區。 + 開始於此處自資料流寫入資料的 中的位元組位移。 + 要讀取的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援讀取。 + 已處置資料流。 + 資料流目前由先前讀取作業所使用。 + + + 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 + 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 + 資料流不支援讀取。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 + + 方法必須擲回 。 + 2 + + + 在衍生類別中覆寫時，設定在目前資料流的位置。 + 目前資料流的新位置。 + 相對於 參數的位元組位移。 + + 類型的值，表示用來取得新位置的參考點。 + 發生 I/O 錯誤。 + 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 1 + + + 在衍生類別中覆寫時，設定目前資料流的長度。 + 想要的目前資料流長度 (單位為位元組)。 + 發生 I/O 錯誤。 + 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 + 位元組陣列。此方法會從 複製 位元組到目前資料流。 + + 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 + 寫入目前資料流的位元組數目。 + 总和  和  大于缓冲区长度。 + + 是 null。 + + 或  为负。 + 将出现 I/O 错误，如找不到指定的文件。 + 資料流不支援寫入。 + + 流关闭后调用。 + 1 + + + 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 + 表示非同步寫入作業的工作。 + 寫入資料的來源緩衝區。 + + 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 + 寫入的最大位元組數。 + 用來監視是否有取消要求的語彙基元。預設值是 。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 資料流不支援寫入。 + 已處置資料流。 + 資料流目前由先前寫入作業所使用。 + + + 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 + 寫入資料流的位元組。 + 發生 I/O 錯誤。 + 資料流不支援寫入，或資料流已經關閉。 + 在資料流關閉後，會呼叫方法。 + 2 + + + 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 + + 方法必須擲回 。 + 2 + + + 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 + 1 + + + 為指定的資料流，初始化 類別的新執行個體。 + 要讀取的資料流。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 為 null。 + + + 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + + 不支援讀取。 + + 或 為 null。 + + + 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要讀取的資料流。 + 要使用的字元編碼。 + 表示是否在檔案開頭尋找位元組順序標記。 + 最小緩衝區大小。 + 資料流不支援讀取。 + + 或 為 null。 + + 小於或等於零值。 + + + 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要讀取的資料流。 + 要使用的字元編碼。 + true 表示在檔案開頭尋找位元順序標記；否則為 false。 + 最小緩衝區大小。 + true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 + + + 傳回基礎資料流。 + 基礎資料流。 + 2 + + + 取得目前 物件使用的目前字元編碼。 + 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 + 2 + + + 清除內部緩衝區。 + 2 + + + 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得表示現行資料流位置是否在資料流結尾的值。 + 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 + 已處置基礎資料流。 + 1 + + + 空資料流周圍的 物件。 + 1 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 + 發生 I/O 錯誤。 + 1 + + + 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 + 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 + 發生 I/O 錯誤。 + 1 + + + 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 + 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + 要開始寫入的 的索引。 + 要讀取的字元數上限。 + 緩衝區長度減去 小於 。 + + 為 null。 + + 或 為負值。 + 發生 I/O 錯誤，例如資料流已經關閉。 + 1 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + + + 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 + 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 + + 中要開始寫入的位置。 + 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前資料流讀取一行字元，並將資料以字串傳回。 + 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 + 下一行中的字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到資料流末端的所有字元。 + 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 發生 I/O 錯誤。 + 1 + + + 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 + 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 + 字元數大於 。 + 已處置資料流。 + 讀取器目前由先前讀取作業所使用。 + + + 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 + 1 + + + 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + + 不可寫入。 + + 為 null。 + + + 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + + 或 是 null。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 + 要寫入的資料流。 + 要使用的字元編碼。 + 緩衝區大小，以位元組為單位。 + true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 + + 或 是 null。 + + 為負值。 + + 不可寫入。 + + + 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 + 強制 清除其緩衝區，則為 true，否則為 false。 + 1 + + + 取得以備份存放區作介面的基礎資料流。 + StreamWriter 正在寫入的資料流。 + 2 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + + + 取得寫入輸出的 。 + + (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 + 2 + + + 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 + 目前寫入器已關閉。 + 發生 I/O 錯誤。 + 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 + 1 + + + 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + 已處置資料流。 + + + 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將一個字元寫入資料流。 + 要寫入資料流的字元。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元陣列寫入資料流。 + 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字元子陣列寫入資料流。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + 發生 I/O 錯誤。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 1 + + + 將字串寫入資料流。 + 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 + + 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 + + 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入資料流。 + 表示非同步寫入作業的工作。 + 含有要寫入之資料的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 將行結束字元以非同步方式寫入資料流。 + 表示非同步寫入作業的工作。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入資料流的字元。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的字元位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 資料流寫入器已處置。 + 資料流寫入器目前由先前寫入作業所使用。 + + + 實作讀取字串的 。 + 2 + + + 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 + + 應該初始化的目的字串。 + + 參數為 null。 + + + 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 傳回下一個可供使用的字元，但不使用它。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 + 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 + 目前的讀取器已關閉。 + 2 + + + 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 + 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + 緩衝區中的起始索引。 + 要讀取的字元數。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負數。 + 目前的讀取器已關閉。 + 2 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 + + 為 null。 + + 或 為負數。 + + 和 的總和大於緩衝區的長度。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自目前字串讀取一行字元，並將資料以字串傳回。 + 目前字串的下一行，如果已到達字串的結尾，則為 null。 + 目前的讀取器已關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 2 + + + 自目前字串非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 基礎字串從目前位置至結尾的內容。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 目前的讀取器已關閉。 + 2 + + + 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 + 字元數大於 。 + 字串讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的控制項格式，初始化 類別的新執行個體。 + 控制格式的 物件。 + + + 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 + 要寫入至其中的 StringBuilder。 + + 為 null。 + + + 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 + 要寫入至其中的 StringBuilder。 + 控制格式的 物件。 + + 為 null。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 取得寫入輸出的 。 + 寫入輸出的 Encoding。 + 1 + + + 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步清除作業的工作。 + + + 傳回基礎 。 + 基礎 StringBuilder。 + 2 + + + 傳回字串，包含被寫入至目前 StringWriter 的字元。 + 字串，包含被寫入至目前 StringWriter 的字元。 + 2 + + + 將一個字元寫入至字串。 + 要寫入的字元。 + 寫入器關閉。 + 2 + + + 將字元子陣列寫入至字串。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 或 為負數。 + ( + )> 。Length. + 寫入器關閉。 + 2 + + + 將字串寫入至目前字串。 + 要寫入的字串。 + 寫入器關閉。 + 2 + + + 以非同步方式將字元寫入至字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入至字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入至目前字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 要寫入至字串的字元。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始讀取資料的位置。 + 要寫入的最大字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負數。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 + 字串寫入器已處置。 + 字串寫入器目前由先前寫入作業所使用。 + + + 代表可以讀取一連串連續字元的讀取器 (Reader)。 + 2 + + + 初始化 類別的新執行個體。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 提供未讀取資料的 TextReader。 + 1 + + + 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 + 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 + 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 + 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。 + + 為 null。 + 緩衝區長度減去 小於 。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 2 + + + 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 + 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 + 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 + + 中要開始寫入處的位置。 + 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 + + 為 null。 + + 或 為負值。 + + 和 的總和大於緩衝區的長度。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 自文字讀取器讀取一行字元，並將資料以字串傳回。 + 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 + 發生 I/O 錯誤。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + + 已經關閉。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取一行字元，並將資料以字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 + 下一行中的字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 字串，包含從目前位置到文字讀取器結尾的所有字元。 + 發生 I/O 錯誤。 + + 已經關閉。 + 沒有足夠的記憶體來為傳回的字串配置緩衝區。 + 下一行中的字元數大於 。 + 1 + + + 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 + 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 + 字元數大於 。 + 文字讀取器已處置。 + 讀取器目前由先前讀取作業所使用。 + + + 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 + 2 + + + 初始化 類別的新執行個體。 + + + 使用指定的格式提供者，初始化 類別的新執行個體。 + 控制格式設定的 物件。 + + + 儲存這個 TextWriter 所使用的新行字元。 + + + 釋放由 物件使用的所有資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 + 寫入輸出時使用的字元編碼。 + 1 + + + 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 1 + + + 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 + 表示非同步排清作業的工作。 + 文字寫入器已處置。 + 寫入器目前由先前寫入作業所使用。 + + + 取得控制格式設定的物件。 + 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 + 2 + + + 取得或設定目前 TextWriter 所使用的行結束字元字串。 + 目前 TextWriter 的行結束字元字串。 + 2 + + + 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 + 1 + + + 將 Boolean 值的文字表示寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元陣列寫入到文字字串或資料流。 + 要寫入到文字資料流的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元的子陣列寫入到文字字串或資料流。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 + 要寫入的物件。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串寫入到文字字串或資料流。 + 要寫入的字串。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + + 或 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元的子陣列寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 將行結束字元寫入到文字字串或資料流。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 + 要寫入的 Boolean 值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入到文字資料流的字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 資料讀取來源的字元陣列。 + + 中開始讀取資料的字元位置。 + 要寫入的最大字元數。 + 緩衝區長度減去 小於 。 + + 參數為 null。 + + 或 為負值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的十進位值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 8 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的物件。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入的 4 位元組浮點數值。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 要寫入的字串。如果 為 null，只寫入行結束字元。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 要格式化及寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 + 1 + + + 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 第一個要格式化和寫入的物件。 + 第二個要格式化和寫入的物件。 + 第三個要格式化和寫入的物件。 + + 為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 + 1 + + + 使用與 相同的語意，寫出格式化字串和新行。 + 複合格式字串 (請參閱＜備註＞)。 + 物件陣列，包含零或多個要格式化和寫入的物件。 + 傳入的字串或物件為 null。 + + 已經關閉。 + 發生 I/O 錯誤。 + + 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 + 1 + + + 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 4 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 + 要寫入之 8 位元組不帶正負號的整數。 + + 已經關閉。 + 發生 I/O 錯誤。 + 1 + + + 以非同步方式將行結束字元寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 資料寫入來源的字元陣列。 + 緩衝區中要開始擷取資料的字元位置。 + 要寫入的字元數。 + + 為 null。 + + 加上 大於緩衝區的長度。 + + 或 為負值。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 + 表示非同步寫入作業的工作。 + 要寫入的字串。如果值為 null，則只會寫入行結束字元。 + 文字寫入器已處置。 + 文字寫入器目前由先前寫入作業所使用。 + + + \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.1.0/ref/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/win8/_._ b/packages/System.IO.4.1.0/ref/win8/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/wp80/_._ b/packages/System.IO.4.1.0/ref/wp80/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/wpa81/_._ b/packages/System.IO.4.1.0/ref/wpa81/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/xamarinios10/_._ b/packages/System.IO.4.1.0/ref/xamarinios10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/xamarinmac20/_._ b/packages/System.IO.4.1.0/ref/xamarinmac20/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/xamarintvos10/_._ b/packages/System.IO.4.1.0/ref/xamarintvos10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/packages/System.IO.4.1.0/ref/xamarinwatchos10/_._ b/packages/System.IO.4.1.0/ref/xamarinwatchos10/_._ new file mode 100644 index 00000000..e69de29b diff --git a/src/Renci.SshNet.NET35/Renci.SshNet.NET35.csproj b/src/Renci.SshNet.NET35/Renci.SshNet.NET35.csproj index 13c104cd..03c6cfb4 100644 --- a/src/Renci.SshNet.NET35/Renci.SshNet.NET35.csproj +++ b/src/Renci.SshNet.NET35/Renci.SshNet.NET35.csproj @@ -18,7 +18,7 @@ full false bin\Debug\ - TRACE;DEBUG;FEATURE_RNG_CSP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_POLL;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_HASH_MD5;FEATURE_HASH_SHA1;FEATURE_HASH_SHA256;FEATURE_HASH_SHA384;FEATURE_HASH_SHA512;FEATURE_HASH_RIPEMD160;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII + TRACE;DEBUG;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_POLL;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII prompt 4 true @@ -28,7 +28,7 @@ none true bin\Release\ - TRACE;FEATURE_RNG_CSP;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_POLL;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_HASH_MD5;FEATURE_HASH_SHA1;FEATURE_HASH_SHA256;FEATURE_HASH_SHA384;FEATURE_HASH_SHA512;FEATURE_HASH_RIPEMD160;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII + TRACE;FEATURE_BINARY_SERIALIZATION;FEATURE_RNG_CREATE;FEATURE_SOCKET_SYNC;FEATURE_SOCKET_EAP;FEATURE_SOCKET_APM;FEATURE_SOCKET_POLL;FEATURE_STREAM_APM;FEATURE_DNS_SYNC;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_HASH_MD5;FEATURE_HASH_SHA1_CREATE;FEATURE_HASH_SHA256_CREATE;FEATURE_HASH_SHA384_CREATE;FEATURE_HASH_SHA512_CREATE;FEATURE_HASH_RIPEMD160_CREATE;FEATURE_HMAC_MD5;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256;FEATURE_HMAC_SHA384;FEATURE_HMAC_SHA512;FEATURE_HMAC_RIPEMD160;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_DIAGNOSTICS_TRACESOURCE;FEATURE_ENCODING_ASCII prompt 4 bin\Release\Renci.SshNet.xml @@ -60,6 +60,9 @@ Abstractions\DnsAbstraction.cs + + Abstractions\FileSystemAbstraction.cs + Abstractions\ReflectionAbstraction.cs @@ -180,9 +183,6 @@ Common\NetConfServerException.cs - - Common\NetConfServerException.NET40.cs - Common\ObjectIdentifier.cs @@ -201,9 +201,6 @@ Common\ScpException.cs - - Common\ScpException.NET40.cs - Common\ScpUploadEventArgs.cs @@ -213,30 +210,18 @@ Common\SftpPathNotFoundException.cs - - Common\SftpPathNotFoundException.NET40.cs - Common\SftpPermissionDeniedException.cs - - Common\SftpPermissionDeniedException.NET40.cs - Common\ShellDataEventArgs.cs Common\SshAuthenticationException.cs - - Common\SshAuthenticationException.NET40.cs - Common\SshConnectionException.cs - - Common\SshConnectionException.NET40.cs - Common\SshData.cs @@ -246,21 +231,12 @@ Common\SshException.cs - - Common\SshException.NET40.cs - Common\SshOperationTimeoutException.cs - - Common\SshOperationTimeoutException.NET40.cs - Common\SshPassPhraseNullOrEmptyException.cs - - Common\SshPassPhraseNullOrEmptyException.NET40.cs - Common\TerminalModes.cs diff --git a/src/Renci.SshNet.NETCore/Properties/AssemblyInfo.cs b/src/Renci.SshNet.NETCore/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..d5769ab9 --- /dev/null +++ b/src/Renci.SshNet.NETCore/Properties/AssemblyInfo.cs @@ -0,0 +1,3 @@ +using System.Reflection; + +[assembly: AssemblyTitle("SSH.NET")] diff --git a/src/Renci.SshNet.NETCore/Renci.SshNet.NETCore.xproj b/src/Renci.SshNet.NETCore/Renci.SshNet.NETCore.xproj new file mode 100644 index 00000000..e1ed5223 --- /dev/null +++ b/src/Renci.SshNet.NETCore/Renci.SshNet.NETCore.xproj @@ -0,0 +1,19 @@ + + + + 14.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + + + + 8e8229eb-6780-4a8a-b470-e2023fa55ab5 + Renci.SshNet + .\obj + .\bin\ + v4.5.2 + + + 2.0 + + + \ No newline at end of file diff --git a/src/Renci.SshNet.NETCore/project.json b/src/Renci.SshNet.NETCore/project.json new file mode 100644 index 00000000..46d8209a --- /dev/null +++ b/src/Renci.SshNet.NETCore/project.json @@ -0,0 +1,82 @@ +{ + "title": "SSH.NET", + "configurations": { + "debug": { "buildOptions": { "define": [ "DEBUG", "TRACE" ] } }, + "release": { "buildOptions": { "define": [ "TRACE" ] } } + }, + "buildOptions": { + "outputName": "Renci.SshNet", + "keyFile": "../Renci.SshNet.snk", + "compile": { + "include": [ + "../Renci.SshNet/**/*.cs" + ], + "exclude": [ + "../Renci.SshNet/Properties/AssemblyInfo.cs" + ] + }, + "xmlDoc": true, + "optimize": true + }, + "frameworks": { + "netstandard1.3": { + "dependencies": { + "Microsoft.CSharp": "4.0.1", + "System.IO": "4.1.0", + "System.Diagnostics.TraceSource": "4.0.0", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Linq": "4.1.0", + "System.Globalization": "4.0.11", + "System.IO.FileSystem": "4.0.1", + "System.IO.FileSystem.Primitives": "4.0.1", + "System.Net.NameResolution": "4.0.0", + "System.Net.Sockets": "4.1.0", + "System.Reflection.Extensions": "4.0.1", + "System.Runtime.Extensions": "4.1.0", + "System.Threading": "4.0.11", + "System.Threading.Thread": "4.0.0", + "System.Threading.ThreadPool": "4.0.10", + "System.Threading.Timer": "4.0.1", + "System.Text.RegularExpressions": "4.1.0", + "System.Xml.XmlDocument": "4.0.1", + "System.Xml.XPath.XmlDocument": "4.0.1", + "System.Diagnostics.Tools": "4.0.1", + "System.Diagnostics.Debug": "4.0.11", + "SshNet.Security.Cryptography": "1.1.0" + }, + "buildOptions": { + "define": [ + "FEATURE_ENCODING_ASCII", + "FEATURE_DIAGNOSTICS_TRACESOURCE", + "FEATURE_DIRECTORYINFO_ENUMERATEFILES", + "FEATURE_MEMORYSTREAM_TRYGETBUFFER", + "FEATURE_REFLECTION_TYPEINFO", + "FEATURE_RNG_CREATE", + "FEATURE_SOCKET_TAP", + "FEATURE_SOCKET_EAP", + "FEATURE_SOCKET_POLL", + "FEATURE_SOCKET_SYNC", + "FEATURE_DNS_TAP", + "FEATURE_STREAM_TAP", + "FEATURE_THREAD_THREADPOOL", + "FEATURE_THREAD_SLEEP", + "FEATURE_HASH_MD5", + "FEATURE_HASH_SHA1_CREATE", + "FEATURE_HASH_SHA256_CREATE", + "FEATURE_HASH_SHA384_CREATE", + "FEATURE_HASH_SHA512_CREATE", + "FEATURE_HMAC_MD5", + "FEATURE_HMAC_SHA1", + "FEATURE_HMAC_SHA256", + "FEATURE_HMAC_SHA384", + "FEATURE_HMAC_SHA512" + ] + } + } + }, + "scripts": { + "postcompile": [ + "dotnet pack --no-build --configuration %compile:Configuration%" + ] + } +} diff --git a/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj b/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj index e4ff0219..1542d83d 100644 --- a/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj +++ b/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj @@ -29,7 +29,7 @@ full false Bin\Debug - TRACE;DEBUG;SILVERLIGHT;FEATURE_RNG_CSP;FEATURE_SOCKET_EAP;FEATURE_STREAM_APM;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_HASH_SHA1;FEATURE_HASH_SHA256;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256 + TRACE;DEBUG;FEATURE_DIRECTORYINFO_ENUMERATEFILES;SILVERLIGHT;FEATURE_RNG_CSP;FEATURE_SOCKET_EAP;FEATURE_STREAM_APM;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_HASH_SHA1_MANAGED;FEATURE_HASH_SHA256_MANAGED;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256 true true prompt @@ -42,7 +42,7 @@ none true Bin\Release - TRACE;SILVERLIGHT;FEATURE_RNG_CSP;FEATURE_SOCKET_EAP;FEATURE_STREAM_APM;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_HASH_SHA1;FEATURE_HASH_SHA256;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256 + TRACE;SILVERLIGHT;FEATURE_RNG_CSP;FEATURE_SOCKET_EAP;FEATURE_STREAM_APM;FEATURE_THREAD_THREADPOOL;FEATURE_THREAD_SLEEP;FEATURE_MEMORYSTREAM_GETBUFFER;FEATURE_HASH_SHA1_MANAGED;FEATURE_HASH_SHA256_MANAGED;FEATURE_HMAC_SHA1;FEATURE_HMAC_SHA256 true true prompt @@ -62,9 +62,8 @@ - - False - ..\..\packages\SshNet.Security.Cryptography.1.0.0\lib\sl5\SshNet.Security.Cryptography.dll + + ..\..\packages\SshNet.Security.Cryptography.1.1.0\lib\sl5\SshNet.Security.Cryptography.dll True @@ -88,6 +87,9 @@ Abstractions\DnsAbstraction.cs + + Abstractions\FileSystemAbstraction.cs + Abstractions\ReflectionAbstraction.cs @@ -915,7 +917,7 @@ - + CYeBA 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 K@E%jp{=Tso;fPAF_`3aC>1@coMS63jG z^0Q7O54&&EY=n{j*2o6;9p%LsdBMi>7gYu1ZHo-3ni$K*Zj1a)?HA*;+?+}41J#01 zBQ!G4{Xl&VJYy`+Zgnz{)(YfwAV*XnX9GE<0y!tfCH+#)q`q67i?qI`k?pSQlz?<= z&_b&6?3uICSvKsk0VQ*84nDao475teR>F}zY#}VqQHdK}K8|1J{BTdBf zG>}^?GR%1%$U_!MJFfwG-XgWmW*~pHsqf)z2a*_Nkb38Xm`~-}OCud_qZ7n2`_sr< z$($1cX&+_Eo^$HrTpJx08RgW2=fVo40mwHjGSuX6y9pIBr+ z=U^aDT4cO)IFQ#Za)9#%Ab+>WfzHuD;-dw*)N6630cjd-B%#%r0pxR|O{mW~C!t(Z zN1HrPaAwB2z2<5pt)@A15bAu(GeaXwHS%(Bk~1IiTxWSYoG-@Bh$hG>8o9~x%yzyU zH}fxpToO0)FN0hPm zIjw!hnAE#8GN}S-_gPktA7f;-%Q?#Dm`|}h-OhQn)lYLT~{R27%~%w|*ecbwtiS!#LS zaYg{Sr2?r3@?XuSr0+N*fjrr4<^}IMqpEmpdeI^~oN?g!YqPN!|K_v;sTybOsGZJX z$WPNalb`pTiQqZh^1SC91LPEoeC(VH4WcPo&w70BDDpF{RF zp<3K`5YH5id@F2m-vu&PBk$L=y4!(#MI$$b2e}^t$!p}t;lZw|X6^SaLT=iZwco+6 zTg|E8Pp+Tu%c)N!glEvtYNVZz6nNgWJV&{stGPG5Z+VV#_W@6IKbmXr$2>>72UK$@ zj?_pyAqQ4-ex_?A5(e9y0>p^loiL|D;lfd(i zM%oGa0^;$;3zCT*?;eLx;|MuqJcl~bodup*<4vd&-Pu4cw4qLR=K}eTM#e{Hy7Ljw zFKs-t+_S;+nvG|cdoGZVEi%XbGIH3wzl5TZ(OnFl!}b@R$C(t_LcW9i+_ArDo%7t4Xq}(gw9a#HtY%q#W`C(eMt%sM|J9+!I2X7N zB4%}fY10ecM}Sljk~@I=>4omEfE;yz$@9hT<3Q#gU~+h|`xKBXE0CulbvJ9I!@I=Y z2;|2V$n!v+tw3HxJZ~Q$rI;GM#C;VAnOM49m$%%`G!T7xG5mtw#e7r5b>7F_0bAcsp^j6_}S&Iix+8hJW;je9KyUb)i! zHe$YfKU0S{xz~c{ea*8edb4|TGEW(cwVHC>>fWAYsT*aH+uZLX)c96YKi_kIfS4x} zGP9L=zVF@#h8d0%z?f{SvEbyt?s1}rGDc64Lk>Y&ZPbm_kC##jl5g?p!+e94$JePt7-MK)PTjY6nK9HMjs2ALYKz?rX^9T1l zAWvK5W%oiLf3l%oaW4V#fz9))?jj(u2_~&K+$BKjCzyENaK8a$e~WB#JAq8K$e-LU zAm`e6wz%Cu7F(XT++{$nvB*2_cYxeukpcHQAP-sOUH5t*znx%8@i+HIAg@}UzqvO9 z`HMyV?%oFEV~gx`?*NiJ*u?Xm`#m5N#w%SLAGr4bX|+5bx<3Lk`Ct>zKivBunKKVI zlKD^fftpT|@Cy$%(z4rKhfr5)q%P)o4?|k6J=pYj$NMFC?$pTBG1q&vhIPV^G_pnc z-qYau<-tZr`QC4VY&zKJDBt^C4fj)Zh#7^G-b>)AImGDRr1vV2mP3qgsqy{@EDerwC-#bLodXVw;zy}Lk-WqUK^097TM1`D&Sh}IMi4~2YAN?tg+8K)M)Gj zy%Phj)y0R(Sg?iWNi)H-((<%=ry}Mn0yAD5+WW9~~ zXs-)tEwZ7G_DbM+=}?1A_ihBw)8)B6*6MiVmO zFh=Hi9{@SgB4>IZ0y*Cz^SzINbXjD9_YWW|EOLqWPar?A$RckSko6Y%nztLs?=5n< z_pgAZ?v2CDn0tlyF?e=bo+~^xjCmq$GA~f->z)H7Re`v}xPJC&GjoTpdl4XQ7Fp`W zfy}nZH@zf~vnMS8s! zn!+3u%dUzQ*bQl~x1z3~c*E9-BhxC9EBc+7V zNVg2>l9tv_ujMJ+PNp*a~gLv zk}R2aF6JqAKXwm^u;F56Nid{}dJ2}CphO)as1hMmd~msxGC5$kT2E`Qfdu1#bjwl8 zjlBpeX3y>CU(1YP?y#iX6##fGyc%lzq_{ZB9VaN*^EX`SmZ@Ofe!~ey>3rSx*rYfKF&#ZlgP`JWKV&vc}zy6cYWk9Em{-38u&6d z3k_}?u=s4J>95S`kPt{;Fnc{;2`4*r@}l&=FNAmBerfO32)P6*ao;rh+o=Dx=gIu+ zbrJaU!#0rmCwVEj>%FV`t;Y&ciB z8_lB@3DUQvY7G>})c<5{Ct5~>9-;SMb%FP{3BYCqj+M z6l8b*^H>T#^l`GD3CP$?f|g3?;aI_eMyXQ4^#H}D1$+=3Xou=|PE~-mAR^Hl|Ef~e zm7`rT^bOn=e$Ot!rk0L>^=YFt$?_@2Ea6E?aDw@(Qb`Gf@frN^2|TJ@9OC(_opXg{ zJOafrgU!OnU2CTi+NV~@HZFam;)zq+y;%&dg=(-QCoD>-P@N|&5&(S*l+F_tWebe^ z)je@*i#O&JpnI@eW{PGHjb^gMMfn2D3b+j5MDRuKsA>m!uCOTvhE4(cBrvmH38TsL z=%^j+99Uo{f};g!{TR$vESgg}@PeMBlQ~~?fpahB6v@fii3iP0x++0Ov)_eiVcr)k z+Xp1a$v(yeCg>#H5}`vF84mRlWHTy@{8`5|VuCC&j{j~4qqA582+?c;qMXO(^IQ(a zs(P_)A_d0IYRjw~nZ;^EA19d|VG|sOcmrmbQ?&0(svvKq^vjE|}5fSm=SE76_q+l8x4b zEvYoax5^kZ_pK-go{&h)wTh0%zOs5TnFi+uNSb2y;A3e0<^mJdtnOdyss@~nA+ywT zlFR~++u=v6Z#1_Pm~kAEbluDf2+>3d0x7{{=mfeeUk5xGZbC2*^bv(mol*xA_=!f2 zYGn%69ej>MQiU5Y^DUf-Qym99z#*y19kV#tsq>|Fg&9ocQ3i_VM<%pxM(h_2#rj*2Wi2;0@Dbbrm<4k(zuzb_shWmj4)#Y5xRjR~M)u%cJfV-6JL@UGDpC zPCu#0jkxi~Wvn_~Js;oW_Xm`Z^2_0rA?D4y44*Zcv|W$YU{8nf$P_1JfJl(pSwaLpHkN@Ym)6T( zm_z90y^!biADg&A`~{B_%k>2Jf+=eiTFUchE0|9w7k}@6i3Zeoxn4kR>_(KxJolZy zCsfPCAcHf7L!5lK`~-T(h3?*R+4^xNEyP`a6Wm~YRrWaO*<_@O9Em)ts-QAd4p`3< z>&3Zy<(CDWEbGwF<62=0*{S~_(|E0B@p*Z>#G?b`#lil%Y(Axgp2CL7AdEml%rx7gUDF66sk|)HhS8l7dO{@EkO6J;qhxv*c zJe~jHKKsF)amz&>6!U7O_SxQSH|2@`V;LwzV;9N@Yh0?Hv~mCaP)jp3e>9}SAL}4# z{H0^1s5E=ckclVUtMaV9ZN8^AyJTWDh{b>&VB$x8X7r}BI@kj_PxU4k911F-M>pcQ zQX32@wR=sx)tPStCK0VNcKT-S7)VBD<%rKh@K|*(KN9=>*pg zK=OK+&wR%xaStsXvbub|J2H?|8-p$W3;ZaSce^g&bC>_W0qI3m>vu&Wv+m*cuF zfpMj?4I_9FQ_}g-m3@VLHHgl(RVhas*_rKlY?qJtTFJrpBm1PkHP1f%M5+l<60#b^ zV?Zplb$P($iifp!o&gO04uLn%R9G&;>Xt%+^*7k0?mygw<~6gZbytf#>2?sOEGsg8 znp)WF@VWI#_uFR;0)ov9YREcQaRc4xPp-AW6!orC@#6J$wY9Fasv$NrXMt8TVCUVF zyWp^t{=*afs?iTsdz+S9(lgCDN81V%Nq-C&RNl)<YBndeQ@TAh4?hy` zqe~b=87sx#e&<#A*B*$kqHt0orm8fE6C0XQVU>pcY?=uss=nA2Q^0Vbj^TDrE&1uGp&A+-Obj3o~s@-f)E<)D)J}%Pt|PtHM8US z_B?0qQ-vg};d~x;tv?}ixMQz9Z?fX4W-@x^N8#-@090>TFYE6=z7(zjukXDJ6Q>7x zP1G#>=NiBEykO1wxUG6Wk&?BRxLuWWsIdr1WJH%VC*nCws;b$FwwS3I zh%&OHYDBa6P@hBxkzje{xl}(p?(ZfoZv@}Xdtj4@Ltb*Kx^ucMSiVpV; zJ*NC7Q@#C5oR0=`MhG(e&5UsZt)4}9eo$7N7=a9;-OW_ImVveYJf5|3apj5IV@MIC z>d$pmrYWH@dYd7Z@yL8Okg?xwfY`0iBFIRsoVdc@yCkzI@Qu3lf`na_op(WI>~}}Z zf~5*24frC|?!*4wcH)3&78iD8fhubJpk3@6+sd*+z2@}58R<5Y);{Nf=*?$@poOgU zraxNLzZj3yWB};mr`8_V&>cQdGdOF2GA5WnNJ{AW3SuZ&0rL$!Nw8b`s;3 zItn*;UX{|e%}~MJ6x@;OPY|Bi5sFbOgT{Q40Au^8b8H03~hhJ=8GERq3~D>DRl|gr;ori z6ZZ!&Rb_hglQyM!C)bXClbRu!mfDNFBOM!(9lxd7z)4|LK23JBIX5uBUVXG0D#LZL z5Ma$QOMX(Fr0v!t(9ss1^h#f$rg4_Gq{aC5l*((}>Cz>#UVw3p$K2kpUvQ>&ecM-| z2HJZamno;LHgwmc6TGaypE+~abLXA;`=(Dn5!gET7gzwm*L`>o>mo$;$8Bl0QlM-CW4V3>PCjfAYwD7ri8cOA_VF zvI>5DE0Z!kNacQOy*4)V=EnaNq(U5UDx>06;nToWu=t03YbEfeBC<0!`Z6KlO`}tz z2vMl{=B^S9p~v-agsAE?<7Pdz0pOU^+2lrj;U&c>Z^nPnAY4xCR~lA9>-W}w>x>zB zHcYuyA_A2$->f$BlDw_6B4g^Ln%la#eed-v9wWS&AlJ{-Kxg30&|636Slrkb@SplX zbcr^Z!ZKj@7wRv?*~XXY+@+VASbaBy)7IcL4$glNSl&XPq{GNkkpj1zd*Ew-Nt@Q*)_kkf|+WPc?@VO z9bO{Q{h3QjqNK*tA9Y7<#|%#mjpoS41eWJLV>gesaa6SZPq|gF6Z%YL&;Ru@(U!T` zhIVZ3AmvTADyNvN2knMg?iR5@N0|z2yg_i2LF=%=E;~lCE_G{Z!5A~=sG65ke`~nx zA8TDYbKo9(zA3fvEVG6t-)<(oOp9)o3Hl^?K;%**`Bz5pWRI1wwTewX?j0_!*7VuQaXHT9d?wkAm)R%d`@YG;idQ0H_NYb8q_grT??wZaqQdWMM zgu)~HF-8CGC^U+(A@aw3OIYq)2omRV$7Ao3nkzQ?q>Y^-3F;B^OP#)dlvPti`}&`Z z+u{q~Cw)~PE`(chW;4#)>}Iz8nR~nRsr}>PD0EGEHZe3{W3lPDx#o}RKiIuQQbYlP z-Z`H~`2$X$&6>-HG64pA;ZfVAKIQcfb=2yAo&Ubej=Y@s&pF`qsi}O5P<^*qK3``8 zH7ckgXO?tdaBxU=bi&%edObjwUHWGQsY=WYxKUDLhyNs6(K|}r&tOuW;pvzNYtpA} zD;GzhZeN8>c)N%D-`i|;L-s0YPE+)aQ;w8zC)_b?ZA^A9L*3D48giM+pX`W>;s%9(;u+VY#HGe0=>Piag@Wl7`g zm5hi6rhD{lL*NqnX=B-B`NHmAtLehqfMoKZ?B4mfQJUbH)(hf2?V+;+5ekLBRplSA z=a2K`$CSz`zsO9oDP)_3?=5}sAjbG?`c_9a356C%`g0FEO|aaynRD*lv`0!^Sf;|; zS)9J+M;*Z(MyviYHi?*ao*hWkSbQ}lpEa7&3-x87h~u5B*}}QWPPCVZ zx{wD`tc1)jh=_9XQ_N&shbS$u`rldfArvW%2J`M2Ods6;ShmllJvl%zMfA|s7$mGM zEWjC3UPknQJ2EX<=H|g!58}+B(&_5Tkv*UL2<}d{xtrDK4@Zlu=-r&}+!$}-`>n6k z3FAWKB{UY51tQ-HHL6GUP*v7?50rs+FprLSon+Ally+W|C^WDwoayXKHw{r+ zauiol>vli_P!0^k8Dmro6^OAH41d$da!2e!oJOHXtZNk`c4SswcUOl$gX^#&&YtQr zePv0gpr>IPIp8{eVeTQz?{U7@%*lmUPVf7k{SM}>_qnCdto{geSeFNO9+@*n-Zfh@ zcMcLcg}!R$+9`KZ;uJElse3d!o$@_Q?lI2i!R zT74oSofnm9r4m94*zH=dnkHO9{F3vffB#yR6P4lUtuYNXSKAO}1eqL;w!|9TK-B0R zPA3#jH&XU~XBPX>1{J+Gv8`x{zxl7hsy8)RPqa!#MeeephR6D{E6I>hbq|WsU7q6-mq($$Fb19^ zzp4sebMdJJn~904?4tpHC)Oz&XP@42@9_>epKBieHfbd)1%Xa9hSet2;%#WU9^ zq<_L%EiCWZU4t0A^t`N3im|Duai=g?jSl;<^U97b1<@J@zSr+N5GRLH+b{$t~zE_W#(^JTK_J@^&+kyj^?i-Dk~kr>>Sav>n7?^=@dpgD;d6}bknMF!!-Qypa}}@d~tiIZm;53!*Wiy zw9H~c(e&`C1Ub_`t>SC6Av<`mcaUwubJ?Vm?xg<1u@2LcM|5PCI2t_16nFe|?e`Uf zmr2{qcE0Q~OP*B_@@%PBf<8zq*t5G+HQ+T~WqWIafeg;rOz?*EoK^6T6EPJ9cZ!Ag z$?6_~e@>iJsAlm`WRDMKIo%qxZzrVI^}W^|ThAz_^;MG1g0;zSUpRXAy<&KZLUVSS z{^R8g`twC6MYM&uL+B6Vak=18=fS^EFU*hb7NkuqD;h^>Z`x85UqY)Mx>DK~ z`riNA=41#FL|HhTrY2Ut!oa;;r(KSHWQzgDiAOT4GOquKEr|yw^9` zW4Rpl9V$MKbHj7*v%D}y#_P^0yNf~3nG^Dm15S?qlA5b=v5YVj17H4v0}Vfl*iqb2 zEy1x4qGsVxr>v$bYUf28c-($%Tq31j(xWjo_tslAhDsS}5=TN7A zL0XIRsmbKn%X#aEB^#=wzo2P}b7P;^mD?+`i+d)~ptjAU+K$(;o9}`Oc+&szma&^# zdJX-3D|UNoa6b`|dwlgl|GjR=SDq2mEs1~d+|y`{D{>Y7fVq^wHIjV;A#}&>IJG+c zO4-I{JWp530OjcI%!l}KZ3Apb2qtuik8q7|G@6$=|L<+Fa$p?mA~q!C%C_~Id8nQ6 z?eW-p?Cj;=bX4nM=fPcMTasD(Kg|gBOdb>$MSE{pOHsyb=K_Flqrp(EYN(BxBIlBA z;qH&kf?!64k<#ho(bm(4S0|Za6<6f3e2#e{b~bLI-KgmHBk=XZc;CfC=h^*u*bqN zt^RlF7-wzL)7m6@2PR?%ro&fEQZGFMfVrY~!uE_!M_~&VHx{Dh#52YR=53jUCzFd)WjhxAT zv(1-y`Np}HIEp{G2&&iz6hwivI8qp+S0x2l3kg+HCF9-3VlE$DMGkKoWITWGxlhe) z{BrsL&pM&4uiVea-@Z~R&t6GOUm9RRvAei$eEq_~)oBy_xuyk!93%wD+H(!f< z9aG&9jC7|OGsbu1k9%A84YEx!ZOl1$O%71-atMnnnH;;eVVdiVTBYylZ6R9wp=n^w zi)$$=sL!VA(!~`8&5F1TzXaJLCs+$4GL(=L)CJw#=O9Cxjm0P9nc4yw8-qE3Z(n9< z|Jfpl6+Q8ql^!3)isls5BeW4@q67tkVMJth6$H)rK*h&>0l#g|68M*vM|*bV;6@BUO99|jTt3s#UvwG&*#iq^Qz!(2B?o_+%cFy4&dN1~HlHePmNXFZ_K z@WmZOw0>>pCI*>|1-TexIKZ#fK^!e7lu1mrjyS{SDS!}&E^^TVI4zIqHOjSH+>K{# zY@r$g=yoAZVulSw8sNQ901-w$qm4*(o{LBEz;D0=a3s`Bbo^0!-aR~sB;yGV!yZBe z@L0$UPjrN9G*WgOkqTJ1f;4`*E95RFkT2w=wiIP{$k$Gf&_O`(AeS^Z3%Ys%qz>`g z@_3n>h!X&LGsX|*kZ~zr!TZBA3bg*vXzOv?8DjzK-7&joz)nm zJ4{yyL=Z5}l^5ym8@FYqI=6;+2P?Kj5FFQ0jhf8cYY|!`DK+r5?p3reAUOsp_jX?t zCTgd17Do(mZ>Xc^&IPDBX*Tp>b}(6!J+^RJ;ob%MJ_-zBMldt zT@Q(H2$6W5Ra`%_P?C}_??e-lPf*GH9f_urG|)clQ1;hf_<9tvo;s!#r%?buO9sJ*CMt z(4rIrt^3v#9c)qhjrl!`&+Af7${7Q7+It>hr5-G12anw=f%H}hC(llI@E-mfb1(_q z=c^P*8LoIcIJabiuIrf1yZg5S#h$+YKb?6WG^_6vEm=sKqlFom&nkWkB&2` z-cf5&Y8-#quX;&~Kz=NU3@#;5{~C;aqZfQ`at+lG`q=i5`9@pUSu+$LgmYya$NI72 z$4yZ?U`ne&S)QP|gqi2+Ge*6)WiEHLGvc;DMWz5O@W==IFi?KL-01a;R%Ahy`4k%N6T@M3NVl*kN>Z893aEna( zBXj`^iaI|01KL3AdIZLUicLalT5OjkRW}?VgYQh4=DTvGZDf}v>)LC&E z@5pG+vv&?kh5^z?+SKNnxZSModlbEBdAi_Aa`O&ib1Z$#n=Z9%@m&+R=I>Qn1dCm7Ps>u{NWL(3rOQySX#G|}`rq`^UB2H2YuD?( zOJ6s^7^;jRvSyOCD)YvLaU8v;6-Ej|g}bJR2G_;EQg&;XuEj;E*!9paEK)3eA^d!f z@e@jx7eqXbR%y7odbh#*< z>x5hx;-vO`jD`+W!1#sfN~IJM;#tNxFn5@z>(hZMKr=vYvdnJ|tP@yTb~&67lDvl^ zI{A{J6TrQTiiS3St(B>zw|+wfe)4Ilzx~O$NfJx6#E)za*gJ`^XUY1UrtR`L&6;N{ z$>WTeCukfA7pe4J+~cQcMTsP+Cs8v2G{O8O6+V>EA=WiXk%2hBySJ}mR~!+e$QZd; zNrw<1XvTFYG1o%iQz1w1qkJs|wB$9&VXc$Q2syx=;(-Cb#xfBDo~TZ{&M_Em1>k)B z0O$1qpcK`qVQ?jK9Uh@k0Q;%M zprso(X1PEar)BDJ6XS-&&4>yNrL)$16RR1 zd4u-f8=vcOpfAF8AXNx~l%HuH2-l-8!?e?UunO7!4DF(N5Z+!UFz7RVIKKk|X`+}L zlRe;yBkZF?3pSio0&+NiZ*ip=$&*whQ7kGgz4#WaBWg9wb47-sg~d#w$Ig9g803|c zn3BM|IBn-&z7;{|zIx-#kryJSD#!xx9f|^H4Mtl5Kc=8U=SCOIXQG?$Y}aMg<(N}$ z>X;@^7?4?I(efWfaSEs$ary|zMIPtIdY&=04GKd1p6nD>9ZPsVYf z=_SsZ!GC_Q;5(Eu%HkGsqLTnalkX6}0Qiccle`FjmP z>8S*eV3c42Q+`x~WUv81%J;{>sz_jD`Ku~KHbExw@n`e&C@7HwrACAFTTu^sG&O*K z>hnO;%5eBQzemSWS(1e69kggVn33x*8i6T7j2UdoRU|`qkOKA>;5NxeH9ai^tKY3F zHeOPB!iw$HoiZvo!7K@Yk(CPYTaoLm^w#HIlK5?b7m9uVH`j)VrAK z;$({{jsJns5)m?6eU`@3qyK?Cqg3XuTyT(l4MbTZ%(6?kgmx(`KlTj8&VZabmK1~Cd%w5} z4m_p^gEdZG&SBZSO?VwK$Uu0sFR(}Cvca`rw(Goi;kylq=T4eZ6RrA`+K1=r%u9ve z72>2?w5KS9%(TRs*7wOg+EIPd4mjwrNpYd`=9?(SA-3*$KM$VC%jVfF9A4V?$N_N# zE|6zRoF?GYd1aOa{S9X>RcG0zRFoW-e1#`=S+s6D%>PiFBQNpm(d_%6BX!p}6UDpR8?ssfb?c97I6M;VIdOS|M-LM(a}>{fv#)o$gAN|Vy6VOTbn+2HNXU2UA;V=kO! zDmgb#L(#~PNWZPeHU@{me5bID3wKM*PL|ZQc!s??tm4~Ax627f8ntUA&8+HPse^pQ zeWp0Doo^yM&5_t2y)b2!;DfYNwrDV2cJuK$Y%Cmfw6&2=h8hevBTI+|& zZ2NEI=0Q~Nz5CzNV%g13;~zdsl#yU{5PG?WY{IqKfiKAO*N4S-g2%Sph4E74$^St$ zdjg&tmu*6ID7O~j=F(yCMm;deSz=^%Q2j9QP#d&Xt9f-!7kuthaeGQFHdz1HO_8iBNvsNvRj+Cr?Gi`U<6?NUITMbcc{5jj6 zA{RI1H*@`6q+9W;?XlSbedLvI10My;_5c>nP`Vpyhmsd8Y%@9{xq z(Pu!_GH(rLv}MIKd#WO&zKkrB{J47hZ7J5plg`Fwio4tIqzn(d!IxFwL25AfrOk&=X>U^`r7Pp*m z-ZrL=z^sbJPeUDMS<%J53iwjz8uJ8qu6zpY@C-eXRr7?4{@jEE{X%e@T}nnJ>mtZawQ~lsip2S=l9hxfpJt!vhRm1;#MR&2%lcPK!Xc%xWIU#teB^QlGGbO zv^Y$%{-^pYdBRNmU{(*0oG;28|C;D7gM2>kuZ>D#vQza0Nk zI<;{mhD9)|dCs~2eQ$REQ_Bj~a}`O+ zUnD-JL4yR}5Khb5K05y=Cm8K8M-hB})`6YQ@B$re({PXWN3|@wSBeW-(07kI2Cg+) zub+|JSp73$FSbnhT?CK8-a=FAgApl8WRbz&Y2m?g1kOv&^Y0OCN?Pn&A1cP#d6Y)p zvZtWl!Y@Prm8UC>XJbe!A`0w*)4_Tt7IEXG82pkgZNUhP6HH%;ul_ZnRb#~M6YvPI zrPwhZpQo6K1Hp$BuJQ=&HQi!erL_T?#0J(8t;Qbw0|{^``4yL|vPJcY3-cZ9+4Z-v zgX~bekaQJylbAN7i3|EiJRBym$&7y#15t2Y1s;Zb6PHd=X>{N);2i%j)`6%Wf7xs# zDqO92XN7+plio_S;QCY)7sD7r5L{m4?|YP?J$v;se(uh=?fyzz=J(z&u`}_KEw2j1 z5R{)8x*7g9P$ENzp9q+w&9aGZJa1vGrgLmZ@(N{YQ6bH*sZza#_>s*3ex)aJ0>mHa z!Z8v4r&2=nug8>AtPznGgV-p*_+aby2nU9^!i2weGci{H`9LGG&G9eKdvauGe8WA3S`{fU-|Xsm;}uP(Dm+o+K`Ro^1X^V*6a5xUGX7F{F?PX+2BQs2zcxc$XqxX#a|eahRONX6Cy6q(S&laW-3Kmn zFWO{y_A-ZsNN)0mMOuCgG~b*0QtiVnVVNlCJKPywH+9$Wr-Q<)74MXS>S+0UPHr9H z#hdkoSMz%oduh90={zcC`7tt{4avm?A#$_}8g|XAE zf$f|W)n4X-KdwAlV#4=&)E67Bj5~mLdVJwuV0}jDGgV4`(x9CU%YTEi-t^S=Uj*?L zueWi@nyCx&SmW*F$Rtv*0uuR3w8sX-LUISb@a~CUGc!-~BgAlFB35%GVaca)xS}St*&ty$iorJ$7x7BL>WX&BjSJpq9m%QB{=XLG)>BzT1fCe(n_@kS^@*Cpo#xARysx@ zhk;?5AfQWdakc_59Kxr0t=X(YCD<#;=7>O2AT}Tznz^Y|`cP9Xk^yH(t!5}3p*}8c zKEj5;g$!!+X_swL5U)(z*`#%aqhKZ7)<5!WWBUj#xb*@*i36A5&HRXf#=CA>@jVvMPMrnn?qz zE~8O^5udsU=U2PMB?BG@HY>M;Cr->Qaix;HEfYrj-#w?d?2d^5?iM%w@d~Or%KX~D zU-v0#6u9L7ST%9fLGFu6;wa6M7k&J*JeO;ynChdQ@HB zn|KblR)su(){z432`da_9MBjX_%9_@r-Ss+Q}pb=m&i}Rlx;AutaK9E{uwJ(wFAro zx7~P!!}YD z9(qLCsSQ zbIFAe7AP&yB!zv4tWf83Bh%SrNRvLNV%9s&l^6@YTxZY8QLLz~)4_CT`C?oPI>}$D zC%KyuFamYkTxzoV;_av~$XRFgi>`gocj|xs%;2RF7)S^k-AVb~Slvk3?@; z4@xcft2XkcCrUSi(akrG+-AV4@SgVrN~?u^k?vFEGEp1u6Z-GL-{UI$jjOt+H$wb! zS^a)47w-o($ja^DB!6o%4%5q14f_v;G$O(|0&5Q!}t;iOo0TG(WU{*6Ks}^0tp3x!-O_)w)y|&Y8fcK{9`VQSo<7P&xp|p|4my262$Qk^`&T^ z+6Ix=w%?}bM&;Li%$Aeo!S8Ls#Q@Nhaxn!#PeNS+R91ATC?myAVspcuUEHvUoa%n^ zY_n~gib_~v^7l?SiRqALiF=>Xl!OMM?f8A8cV&x)CcqMiC+E z!@J-jb+~&5)eU#@vzz2=*$jt42C|S2bRo<&6sITZ!`frHmL55~!`&LLቛBW&u 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

&eK}CN}pBI_|J}>yq}P!)hIFg}L%=_uuv>bV?>R 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 diff --git a/packages/Moq.4.2.1409.1722/lib/net35/Moq.dll b/packages/Moq.4.2.1409.1722/lib/net35/Moq.dll deleted file mode 100644 index 186486b16fd1de93c774fd399975fba2da146157..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 677888 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%0DDf-_FOC) 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 - - - Moq - - - - - Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Defines the Callback verb and overloads. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - -

- Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Encapsulates a method that has five parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has five parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has six parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has six parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has seven parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has seven parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has eight parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has eight parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has nine parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has nine parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has ten parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has ten parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has eleven parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has eleven parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has twelve parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has twelve parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has thirteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has thirteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has fourteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has fourteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has fifteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has fifteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has sixteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the sixteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The sixteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has sixteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the sixteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The sixteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Provides additional methods on mocks. - - - Those methods are useful for Testeroids support. - - - - - Resets the calls previously made on the specified mock. - - The mock whose calls need to be reset. - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Supports the serialization infrastructure. - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/Moq.4.2.1409.1722/lib/net40/Moq.dll b/packages/Moq.4.2.1409.1722/lib/net40/Moq.dll deleted file mode 100644 index 996b8c9ff019efbf1fbe8cee90bac0750bf1216e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 660992 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

mDv`@-OYeR+kj@ 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 - - - Moq - - - -

- Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Defines the Callback verb and overloads. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Defines async extension methods on IReturns. - - - - - Allows to specify the return value of an asynchronous method. - - - - - Allows to specify the exception thrown by an asynchronous method. - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Provides additional methods on mocks. - - - Those methods are useful for Testeroids support. - - - - - Resets the calls previously made on the specified mock. - - The mock whose calls need to be reset. - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Supports the serialization infrastructure. - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/Moq.4.2.1409.1722/lib/sl4/Moq.Silverlight.dll b/packages/Moq.4.2.1409.1722/lib/sl4/Moq.Silverlight.dll deleted file mode 100644 index 43c0f181993f2646c04a1f252be9fbcb40effb68..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 151040 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%0AIgY9%Et z^*h2|6)D|{Mzw$bm{Jr^Vi8;cQ;ZYT)JgR-#i3>5kU$0xZx=7_z|rq?u^!cN`x0z9 z_o12J^@36-cUMNb$sZHUo)4rA9)&MUu>6B+i#a=+@hH(XZZ3Kb6y9Pyk#!a~pL=A+ zRux8<0&d0_l2#udqKpi8XkWsDO8hGj8GEO6{Mkm4n?tg|=+*{{EP5-8GX^R*5&bcx zu3W3-+L!%Y#ngsGoi2wdXieTU2)c8N*kHT>CfM2=mC%oYxyiQ$sMTP?cSctG=N{iJ z9_Lh&Z+dTHm~5s^ZWP~psnuSA3?A+RW(zLN%$5@+W*J%=D=(|y4Wv}g^X;|=cdH*0 zyRVIyhv)3gcy~E{B1($7sZx|c2A@)t@~bGGhLW&Kb`DtwHhWwhc2^J!G$CgS;-n4^ zvGC5UgVIn3d3EY=LsHb9N>Kt$$f;M98@KNF-5`S1

>9Zd2U?O~^6T-Tf<9a_J_t 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 uF%kvHKt8M_Un=f`)`~ - - - Moq.Silverlight - - - -

- Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjuntion with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjuntion - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Implements the fluent API. - - - - - Defines the Callback verb and overloads. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjuntion with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/Moq.4.2.1510.2205/Moq.4.2.1510.2205.nupkg b/packages/Moq.4.2.1510.2205/Moq.4.2.1510.2205.nupkg deleted file mode 100644 index f4bfa25db5be509ffab150517d1e2650360fdba6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 648088 zcmb5T18^o$*De~{wkDp~wrx9kW80jV6Hc6oZQD-X*tTun`Tjb$&i(JLd+MC7>Rr8` zz1P!g?Oxrh`)MUva0ob%|7<5T8j@X0x0NTL|BnCd@E`;rhRy(67e)qV{A6yf=JZ@-f&zRh09#|% ze=}SxtsGrQ{+Zaj@RM1(x;pYOGP;;r0_==k7#th{_WwrA9h~iqUH^5REf^h*O>K-V z0E{e5OdO2=y!oFTWdEI$M9s?)@c&`7vodvdaB(nqWiWNH`yXWg{Q5`7%*4pV$!KS6 zZ)FZ}aU~;BGj_HBxbl-R$~!nQ*t@wn0!+zBq|NxrR9H+**;ttX+#F11=4`A0PBIe4 z|D99+9|gl`2XHkuGj=s*G<9$W&^tQ+vvzj10=WD?9Q(hQ!Uf>$ZeR2=FA*sEUcVtoUH!> zW&5xA82{V#5>Wb=EEphQATa-xEbbtx0c@xsAlWn^AaMVZ<$o^O|0-8fbZlJk+nhh; z)DH!Fx5hIzq(pzCJ?dz;kjp+D#+q>_F14tX`GQyop;dUz^u|!P-|f4!gH9q?RjZb* zEizaHN)*icy}6oBe?Mgu?TO=7M1Op)3paj0IbeU+yL2bqHe}HRwY2$tyBnlNH~4Q4 zyQE0t19&(>>5Bmv*xK8%i?5Y}8^j22?^K_i_3)UIH5^{>#v)l3<;jtB6yN<0*?Jq8 z+tcqaH356-tz0o-vqo$y@nHj>vtELHPX#ji#ZkpMu<7tA-`bT2pvsqpFZL(nGLg^b?3W!LutO$oZ3j4 zes-t0*o{3Me=ea2j+Hv3aGWhkcf^=BQ3Hr7qRZr}c&@(>eFO!SIXJwP6IYF`{#H>R zo0;fFiPx1HLE;Fasurl{6jrRgsQzGWqMK~^gC!xB>yR`3ZfD%&UzVuh#~=e>>~6ou z44>_rcGzQ)RwJ`*(!wY!|%TgT+ zr=*P0;~!huM-|!C$jS%<)5ucI5RIJ>;LNd^L?hk4WkwL%Pr97#lM4Y>jhp3SNaq~@ zTc7(7Z%4h(-XMTM)GeXJXGUrdwmMCYe|Aa_Cl)z)*z!ktjvzxp-B6uh^<3lUQ-MD} z`t`|aNCvHFX1fulQew#&8@Hpzy7U|yTWZD zD?#O;;GP1h2Kwz7#$s@)1{#NEurFR1w+m0)y*=nIN>VO?`b$^ZkE@koVzC(dRg&5WhHCG#VlcznPe`<1o&3ReQYaacAc{R z#%da!JDQ4#B1TU>6qX z?aB5yf-sXxL2{1Efd>ng2o_YI05Rv9sGQ(E_xB#0M~!J;?JOA#4%C9?`?$6mRikC$9AFq$%{L8P2ae9cEEd3q0n1OV{Rs_J zp!;5En<-Z_oaYXcpjs}_f$`fE#Lh~3Nwtu8}8-JC$3^2)c6z*@EQ1q`QYz!}x z6!Mv7DZ)eRlKX&Rg<=ZqsG4Z*rCcbFlf{88cb?xbYj5k~uy`$D7cCDTMy)8)}t(fUsp zCTX419m7I|EuyC`I!ousv!FtU@c1o5zGVLDbN*@G#6=Q zXy&rjYt6m+fiT%7xE^@GX$2m?nn{!X`Yk30Lmnmm6A%_zl1<6U9Z%U~S`Wt?isJ_M znFS6v=wSber*Zyqv9R3s@*=x(+-G%+JX-Rw);xrL;FJ$7&>LRxiG-FI(nVUy4G&!h z9X=(^ZZH-E>s1&|N{|@NYO=7$6oC(M4%I#Ap1cjgRo29|MKsyYtl&A~WO%DF?ty(~oTbM(?LSV({8;cmxwX9+v5|GV8`@K59t zuGc$g`I*=m5t;MI2# zj3rlUUOW$XwiTJ_Is* zRb<7eep3tGWYlrcx#_zqM>`>6J5gTpwA{$DCjNL#(PZu=81;7H^27ciru8gefzkxPkgwK0ZK6Gfg){ ztjL84R3!LC9<;O0p6lYnUU=e-Na~ME5XaX?iQyt2E2cV|MY@sB17gdcFRy{mZoN-V zQ9J%c?RyjAXr#eE(XKzE-BAoJi>gmp29x=sc3OD6hAuxa6pCB}n}Fk((s3lH=WBR$ zh43|=wro;pII^aQjZc(Vg-8JzrGccQ8Q{Zr^fU@)EH*0--`4+uXPg}ouzbXQ_=HJm z3q$nV=(~~`_M+Ok)Q+n(6YT6*21y!=U)Z}`Ilj@=$6fccEkalq0yI-L{PGGTlB`&| z+^*3~XG9R^Z9jLfZV0QgMm&3F%_Az|O%G9HD55X7oC}Am<(L&F9EfE-3fPZLvJT^Z z|3ON%;9;U1Aq4?-cw01^6|Sq@5q6ZW8x%M7_u&bh2v`(ZO}qamc>D8|#+TwS&-LiR zb#T$W`)i$T^^|#5c3c{LsMuP4Q?R{aW?o_$LSeWl$ya%Dy0cp|=&QAIYKS&y5IdCb zyrX0EmrRCd_pFiTs{uf?Wci7?V0%B=_|FxFkPuf-vC337)8XZSKHMbgH~&!&)x)!6 zfMzL6ocBhI9nJ_7&)O=N4G>qNfb~|9);g_;m4`F3I-4;}?ZxnNdlu1iQRX9F%SS3@ zAi&2$&-%z#fh@!m&^le2>7;*s!N1&{r(%2dt#}*xE92L0ltGcW@uGRfB74K=;hF`J z-IO;LP1t&JmBt^3bHDZbAETjWpkm~*teTsl4WT+uSuv5p2+a$*o5janw4`kD8P|rZB5&u16L%I zzEQ}FyFTySSV5PGy1h^F$w%-PKwgCA<2Q(E?T<7i0F;C*R?7hHP2qKXtFZEkTwRuG(9e%@=XrnO+k$KHi>`_JxZOx(p2Kmm93NxQS`( ztk21@QY1)R1XtC^{0Pg+Mc#{X(;N)Eduj$O1d3FuD~& zCBOVWsBeG+Q-_zA0a5>oWsAdBXIan!{@cOBq%P3iN4|_^o}vlE@1uC9+YYfMXZ4gs zs+0Wy44z4w;fo9s1Y0BzO7JxcIt9ISzh6UB8LMqC+oL~n{M8iuAYhtx}YngNKBaf zTuU)@3+aRFH-dUZM+5%Zw?DTqRk_d)1&lCq(XbM z?StwtuLUaKuCroVtAmfDa7kK}Z%)kxyB+kiNtaIIwOAa6TjBCC6a+9lLqD|z(7V!i zo@dZAF(HnW5nrZ~Fhu6iMr|T#f%I+yyUI@Oadf z8bL+3|Ezi*_A^^js(UOv=e{r&xZ@N~Gh_>OcJ%GWDRa1Xy}AbOAM2k`y<&5-Twlyx z`VkD@XR9G(O(dcm)c_T_wOo+ zi74^1wOv1es0berCzf341X|nVhE!Snz}-tATw_OAtZ--O$TSPPU2=+s+fQ(Yz75QcDqBuLGMuV;&C z34z(de(9EQd~aQfiK*%oS*p*i8|QEqywvQoq=vkf%8QV%%(mhP!*VJ4Rad_L(q8F< zPoAR+zBj0E^im(`VYGm7GEuT2L3Bs$KBcJSOhI(4E?qBTl1`hFV7DE?zL-H?|2OFX zDmKx55oi4P$5)2QZz$76wzc3Xj)yj+^T3!(H{=$o8YT6XxZ+ESzxI8rMXs}`odZJ- z2rCdq!|EX_mlVkE?t{(je&6rVT3{NBn~r3-ZOD-kkyWnSKco;s>TOaS?VOuOC@1#L zMH$vb_BXc^-$tS7Z&pAY{{Hk~PzQ6=h#n?gAGe-EI_V{L{xy+T*u_cN)s|n~&i0eD z&k$l5fpgaVp2gN)^+RZL$?p!2mmW0i@3-vY) z>yHCbxRP$zVu-C_K%)!l_a-(#k#guN3C-zJBG|CIy0s6pnRFNH*Zw4YzX#seRk^xV zyn~lpx!kMsT(q0vc>}|7dqwX3vnp@334lI z3xRaFesJzY*4WK3s$;*L;cdw$U1F)6cVybdp>MGNuDi^cD`(pDfrEgU!GWOu(_L(> zOc?C}uB`0;C0d!;+WxQPmxV6aECO*%!L9ktdH#_r%7%{gF=-^JIXNj9_+R`a+Ht>l z$#-SIz+h2eGzS#=*(dRkkw_tilBi3Cgt#FOvDDPml(dl`QyjKkmk!7GBTP7b`St47$pB98ZtwN9yU)zBugaD?8|4mu>tWde|S9S-!Tg z&Y@4Y;hg-D*b)SCOk^!_O&FLnRYN5vuasowIg9$g9ckHxp zYaaIz!gD_z!_F3cx&esC-?t7A1K$c%t^cz58KXpjq9>&;qdAY>`uj6ur+5;i--CF7 z*L3mLq9%WvDqiW4N9Cq^%y}}VTV=cMzdDjiNa)+UX`@$F)=KRsCWMh?nO zOt%>wVIUs=;3Rye2~BNW!#zE)bx2wb-(8C!b=EkYi>_jzp4N6!4wwPWm73BpA!O=I zX(!*@amYvkfi8~^OE`f{J=Itoi(%pg`rGO#9RpMzL6VqVm(`;I zMHEn26}sV|t28Vnqm{n~s5h@9Zr(c&Q?nhWi(eN?X*ut1=i5FjHne~rKL?vd-*9(U zECa3FRk)gQB($j?BG*T@=Q3e!MI^=^_#@II9k!dv`iVWgXzPB5Jv^OMAG)<7pjq0;sV9xh?O4HTv(8L z7q{D8F$gH99r7t6IVqYr;F0sNUe*t<4==>s~7>k#f!AaU-Vcyqvm=xyckV`4Fg;XSOZZ@s)75Fn}}*w@C81OWo@?u zGq%YkJyXXmfpJf7CdeRqs4{cB2je9jp)zOY51q4%%Lw5X@w^e-yb>~NmVB_C0$G*` z?xb^I2+hmSHu4hmuk4Lp=@Q+-(Kqo%EVESKI-|IIW>(!Q#-yGUtKuT-6%4RFrFofT zzNA~V14l75D>EK!C;H}r$zxtpWs_o>#ZWXAalsQ|f?4O{HuUT?q!ucV%=1IN=`19R zIgd9R{7lreC!!wt z*8OilWsOz*E&oP_YuwH{2kY2JH{nYdFSGTAOQ>ulA$h(3RtFYRk7YP-v{uRR{gMXn z;~dN`bZNAbADQw{ce?_hcrQt?#~*W$FcBRf7cwdl-oVt@Uh1r!gc;lCN{fN)zmy%T zrFv}HsH({em1YQu!va2=-}f^dYs(BvfPta2t@*}vzh70wv%UR>51RqKNt2&wO)4xn zMn>A%{xT5#NuPh`&%{C5-;JH}N<93W7(~ctJUE6N^BOQ87|vDEVSsWP;r@(?AJL`^ zSEI$<>NHA9{ih?gS_69Hk()5(qlz)M(h4!V{=0uaUIAJizH9C&r3CE0?KZ#!@V_R5@r>T|w-kvR10wEtpE%@sj& z8u>VHz09lYPn5T?ct>!QnlJE)FU}o$^};wYHYxR^Ytd}JVoc)B)pzmSB%OH!U2Na7 z^Nz1sA_SRx*8mUMF}-aqi2~ROBRX=gs?f^$n(au;6nKqy-qV~uP(|1~0=d;q+4(8w z`L5XqZ_i|82E#cjivl?emj$jgou;jarl`ouIUMw7HRM%=lt$3T*qfN@6)EcOw}r4; z_r6bGti(2(HafF|Oin23bR0T^2&jT5)6RyPI+Ac6XhAefH?gA&*Jk0@z1viGx+ z(kYYKw1{O%ITR=UVezcOj5^5hUaKCh6D-Rn3;Cs(bjQNrEsXsy-PlI$b5|MO$iw6x zq0n5zIQvfQ>ci^LqmQ)W9lQfBO?Q*Q$Llu`xgaiuqx0}-NNL*gJJm(7j809&1dthg z83M-{b`4EC-g0*9bVW+r=ZAUw;h?Mmrd%N#OA~sC7ZYf_#KvC#WX@;~w zm6+Dbkd4?m=_dB!5|FhD3WbJPJ;WvV_py3s7CP3(KIuBwfBl|c{zm!WV z=rIoXG|P{vRj4de{9f)6DHpvEw&OGRyqo>lX8u0Qbxd>KWD4-%L=A71J9IY~q6qg=0&9XX|krug6m^fD+UT!rlyj}1j>*wJw`Y=@8 zNl&k_W_Pree2ZG~Y2HYveN5}gzEAl9eZ~)_4kar<)A=C^Qnri&1~;MmssD+;f8pFz z{UuAjX99L;3kn{}X)@i4f$cRFg1&Y#N=`qtCtxo$m(*f+E;6dl5I&svUjZ75TJVZ- zgB4D<{^P;j}u!Vy`XR-Qtb-bE+k(or=#kP&1yxz1ULlGZ?e+&ain&xSwn2t z7B5X+b-neTwrna+wr)yp%mC%I&pc|(nC~N8(_5EP(*R40$XPZot%|H|5Io4=W zULvDeA$w)!+&M{^my(BXP7v->KDgm_&BQl|sf)4NAS|;{|HOCzi9JyG8 zZL1Ez`H?&~IPRzH7%MR5d8Ab|3+=_m>Da0PfoXj<^@zw=q$o&FvS}Z&a2c{Cnt;2c ze1iAOSxxAErBOtFRj;`5zOA`Z^g0?taKmHw_%|6NpC$HCNa-(QC3C&Fudn>GmPx#Y zxcsmmXFnH}2fS_yvT#?N(yP|8D6(F9qGA@R^I6Abo`@hb+p3k#Fw^ zPRjYVh*f0CC5?8}lYo7$^o45yOH^N(4rh1S)jnk+L|&p+}gA(*@)Wg8v4pNdL8+M~8-l_XTz6;JrgH)tV0BgkHb z!ZjtG)99;sB{TS_={;Eza_}IT_CD}RjKoGhQH5*Iuw3;6_+pD(6PfC~evo%U+PVJB zXhy%YuLxa4n6-bgfX64-Dl{wZ=~mu@xBH=wgI+a)2a@MV8LT z`eB4&SrhXTi07GM3XN}tgJJ;AP4}V7H~o3zbO*UGKA&;vPL;yo7t)SrD(NXbZ72J- z>p&A5^Q1SY%oNLvOc04zx18~Fv%s;Fa~O3xh$hylle3@MGfU~h1b6254f#ocj+1QN zH>u)H=Fry`j880Y^P)GIfELU(C$4eF{-KuuJ^#(ESEbFRbghSY$4A6Eh4w4+T2a>> z`l}ZTH=)DKJ5AUFFmR2FZnTR9?Zp5W7GqQ@Y{X#RK5uA8d6F6F+pMdadna9AiQGG8 z!}>vSxp`9BR1l{W8zFFi!kNbziPCeOB2m}UIgC!Wv+bdY0B^gD??9{iTEl-=XvxD8 z#mI1JKl`XSS@1+Zh_EDFDYmM2W4OQ~jQccDr~iB_#lmcQ2w!ayhi2ZpOI{p;HORTK z%^w%?a3k4JLV3*f#(e56dr22-k(2Xij$b?D)nm-BQOYHG)%H@;VL6c9tE9OU3 zV6;ymdMDsCLRn(alGBqa3Wi9+F#bU{d*v*Vg+F>JsaAY!_0ts5c&I=`HeN_Zh*}a7 zo!tlMd9LBEoK442cFmZeu(OAJ-pA5c!|d`HE2UK;xlc3Z4&PBwXp0>2RpRxS^c$Y`J38?jnD|XG_RVtF6a0~Mez1-IYN-BdnDkL2 z`^8EAojLlwH1ihy(F#O)twZV7rx!}ydd0ch|C64*6w=7Ij_uiX90*w1HDt2uf_Lo? z;KJGHWl&UHQ`Ae(g`S3lpHzZEy`m#Hyfj6)cZLI)ZV|s4=^5MzYjd#MoncCx+zAZm!7szmJ>JfD4$Y<|D`r<*rKw;W+k|hvDaZ0)pTcv zt5J9~*Csa&1S};zr2H273ex#NAHZ#sve!Wff-~YF`r%%pVJzc6aa8Y>2vQ*K#V|3E zm}NndE_<&cT~(CfET1g8q$1y$YHj2G>Bv_!&8~R}_Z>N!8tcT<$GcB$68K7|d+zzgUeA!qV6C94 zZUpM?*1ltqjbuRPTXG{nK6OkOkN?gl_N+DUn{~G~b+>`HQX^K&y7X#Iw+5&L?V!BJ zIlz3}D93EV=u%X3B|v0W62Hclr+qYzDTUsY5xP#08Z>oGCFG00Tw_XrOavvw^uSLJE%Pa*v$ogL<|G=W^NM(VVgV-7Rl73PpyI-H$zEN01g2gpgo z+aeewIFW%iO_EY-pkO~TAsv^21b{b2xHn!Pn@s2^OR8eV`IKuYlna+XScPH9caxk( z^cWdj&kAfRqbSoIW&PBw4{m|Jzc0Y-1g8GnWr_j#n8{yBU7&}n#x0?2Qw6Mh^e25t#(-S zB9#;yTZ%3mTg}F-RotjTlb4_COuSseii&-4D=xzK>q)rj{d;i!rGYkDK_wz-j-{Fx zxq6J>jiv8Mk?rw_82PSiLP772@a2BK1=fb9XPGL_Poe8B&9gboR|-@K*V0`58Qc~>@vG}>8_r{a4_U)KpHZX44Le| zFT%`AF%6Jnb)wAAlTp0aEDJGOgvXWHE%txX<(uuReLC;g?Tlj5HjmT~;@E)6OG`3+ zNwJG->xuhlH0}*lFJi=tOL6>BgP(NN6S*WE@QwdR4NbSy@t0=!>42u%0YaKX;K%fn zcW`sfIl@JzYCU`#`pU#LDK&zx269rjD$V-~2~O_JyHTfVN-8NNzi%xoAc;Lx7sV_k zp3}EiRdP&Ze8TIskxsKSSh*Mu@01q$IwoC>ofP%bhg}!5eBrmU58xL|1GragosqPx z@v6TZrr2uk-lM{{g>4tQ&?gP^siO(lPeZHDtgVCry*wtFyY^E3g!E*lWjLhua@4W| z39C(wZR|3HqKUJ2^8=z)57PsKkX!y#))|nC_msFBc)xh@tKWVB5gP?>Uj%KE&vsE8 zrf(U9mj6g^ShTqmZgu{nwrITh{6}pOXoezY74#IMlEzpgnLBit z$&8pH)Bl2EMXPfvoY*!}AmjM$`igH09EiRo{|}B{*YqFUovbC_j^-cSL1_{#lhz|FN!DEP4|b(AIsez~Q-GP{cxxcs3UTSLLhoFK z(?)wwk-Y!2Mj7OVy-h?K>syTe(_#6ke=H&?H{nG~0ySP!OD-7t_|&sqX`wkb+%gBa zqcf5GCvOxn0mvYJx0D`A?EpP|^1f7QT zqo3TK0pR2hVn+j$cwh7X6yrJt#evoBAy^;(mp(em}B z%K;;f^`_Qq7P#TGNmJUExu>wqZ}Dr#ddxGfP3h+HKgqth;smQ1k~6*pgOYNL9=>l0 zoPFiLYj$QZ5n*IoWaaj4kB1D!_o-ZZ$B4!EDPvNy004x2F(fXhdnWVDP-M!e#ZNa{ z$!zO~Wf}r!nd~o?`_L>}w!7?M(h|fm&H^>^>kJTdE003DmDFSPI&7C!16N#2FLtw# zn1WU#L6+4+J1;~5derNHs@f5xENm-e3!&v*h0!5E=duFZxtL`EE*&bgAfvu7zdJ5ypL;;xyo`v1tFSNSHn1+ntllc z+@PsGLyT;l=~ih;6lFU@1?K@5@irA_?*e8IlK{uUp&F7AtTI(uaD>IW^9ydJ+lp88 zypHMbWhTnFGS`oyi_B!TiJ3v6T74SykE~p(SyULq?E3-zK+lewpmQ}yI48&>NlcV^ zK3(f5?y?2g&&5Wm0QH!Ql49P+%aZE)cMCjrE<*M|`icL1&^y-Nm_u8j*9m62T+ETe z3Y2m#&bjN{dc9vNx9g@eh_z3f+sOmMR&q$#xDZO1Cty%P68L)*+u|)&8&b;9>ih=R z6p=gf>R-RVH>UiSQnNeSY7{)XTsZsCM0*iZ@$vzVg`{dwk`#OYASwiD7Ou4f(hyUG zQ)Vsm(b&GoutA(kHnX7}3{e>b1=fRs9dc0?1ck70dFSjEH0*neVllAtdink}!l@n; zS)e4u2%d|xV-_<$^oUCkuS?KuBus%&)x@d+ut9_#T6`fNxrHtsrs{g;PjY@k@B+>f zY)s9}(o2;)xSLmj&l~*`JY9M;YIE1y{cyZ~zk0vSuVRxgdhdOzN4@?!Vc_LQhdxk0 zLJ5-iFMRXFdP8|=+CYa0i-hI&Eaeg(kbu$-)d!={bf2~~K_#RU%|~NX3)8C+v{GT~ z2S-{9nxu2!g7g`7WiZrg1eC}mo=U&x%zPnAtvWm`II>MHA{D1=w4 zq{)zhw1#Bc0@lE^ufW8rgXZk<@+}4ettSoB(`|MdiPPwIHO39Z zZAJmKj@pW5#Yvsr5z`F_#kX*d#ZY?U4X*DoIXKZ0NM*R4*p+f@i5j4fTyHAishNoE z${B6lm|Ooji8mLsty3D}DJXqB7=`Jb+Ivg#U0 zl*ypA-#&UNuPoyTdn^URoNSBrvbwQ9ZFSq9Huik|TKvdq>6F~`+q@FME{G5-ul=D_ z2_%6-IK~6q)^V(j7#xH7T6doZ`;UvWqLgvNqlCADA*sx*qwZmaDNaiSxtJ>8`w?eB ze}%sK2aT*QaiDt!5;?U@*U@sbG z1*Rqo}iFBV|*fWJv6C%zfBMF^td1vQ? z`I{c;;jottAA_NWy3}JGuZs?jRfb#+gmzhAbe32j_e)IH!U3A{w^?|=x*i5ydYOg1 z0eq(2MqmcTr+oR|!Qo-bVcj;R94-Fg#3apEvK7I{5Zxb@kXjF6-ve|Ms8HA`>zk(VcSY!{kk zUba^w!1YazHaaMQL8)}a$kpJ$j~_vSKqbPO52^~o{xl%`e$Bn@+rwvOM$<}5WKUeQ zLq^ZQ%lh!P@(1C_cH~F)__hz%va9>`=(hgL`oQ+)EAMh(tzbZ1A@y44plXGW>?L|6 z{}dg)&IK(G^omR0#b0DQ{TY1SuunGuy<{aH=T<7DG@}%tzcL+%Gn@$ckrBMDN*MwaO{uir#A1C{5e9w{q5 z+kY>%4Fh+1@hKna3*D&+!`zDdD`*bWxO2|+T3vtJ!o~?6jk|hs4fkC!0e>r#jpIpS zm3ijmCZf@+n&AXkRGa%Vii0x_@t19c`9p%=7~E9ueP`NV^vUHjx8eC2>L8@dD4?hT z&-1T$B2;Z{V)S)_cZdewXkUoxJ5ua_QT*iHDH%fKP_m4k;AmztdQTsMvSo6&vzC6d zU0=(B+X_s8-bzQxski!MRkwN={IZ3-046_zMg59INtG=sN=UYPO+6iK7NzwhH1f9Y zC3leqbtwmh!W^f7949umb0yCcqE*BU<}b}%hem(x6U(HMp66yR7pgU#pZm6mS0IftwagYEa_Ay9|&E zzC67i7Sax5Zl;p!h3fJt2Mg|6sZ5RUU-9=O=yqt;HUd|xG-`oe1dk{OVpR`O=BhLW@l&tec!MaK zoUu-Pro}1Mvd3MkWIA=NjpSg+V^tA5V;EX^#S({WKCJR!=)8i!z;p-mh$y-N)&v&9 zr@z)dlw@)*cm&{DBL$(Jf=ATqk+yn~*@R2@&`auUe}KEMq^)5?)r7xQioXfHSU|T( znT7xTL7?*!$jm-oOA5&(HK9kc-|gi6k#jwmaI?B{hmVQj?$B`g{C%xMA2a|S3%noJGB9eycf~_3Sfdot2Yk9Or$dYBsyBx~ASyqyzTXWv% z9UVzm&d)_yDu+yn7Uxj&TW`WXV-YsTj$Xt?_)O^Am|(ah{D#r?l+Z0BDgOgyUK*wy zeRe$b)}foQ!lb8ad5cr8;$Zg{FG140U0%COYcexJm>hq_!Fj@N+84c;Q=b(2W7$76 zR)t&Pzr8ua*xR|*cn5J?SmwT!iUM#?Lu}Bah8qlUNpHE6C}D3xJdEv!M#5G5{CWf7 z+Ireiej4!hCZ2bm2t*cGDa6KXdac?$&yz$n^ZO&EKM@2sK>a1aoUG9CG`z$#YuoB+ z`F;JDnplL}T1sFb%3zl>5~{ytF~hytdET*8=1H4U2M8mpqPZl!{}9C-XH8Q%FhQ}$GMNup|q+!tJ89sOnWlQ0Q(Yk3A1}QRDwS}h;`fzk>782@lRKM zwVumX&#YE03YmTt{@vix`6K1G(*(XvPOCV0y*`W1{pcTmJSeC5ahgR>FNWw6^WvH0 zgP7!A6S0z@jX;x?4CYpbIcex^Y3jw4*+U(mgcAKaX|FcNt=?P)h6V z9xJ}Xk`S)&9D|ErxJ5{3t?VaZWVQn#pJFuk-}#v*gYtKXlG{6|zaF8VR^Ml9aur5# z4}s(hr|Uow3|`{Nw_vf(R9rBh@3&g%xK+ss=6C8Zl_btq7;(%x0gqsCYR{;f(J(8d zjbOI>7LqAp-30SKtU~QpNGmKm;f#=f5UFm$(G0zm%L-N@w=eu0-BvK0Y%|H!+&}1- z%zfNu03_r&tQkMd!}%Yff3LtP4or` z&9p}n+p728EQ4IN;8v@);r)hq!iy!v@ivd@c7f~k2~qCpfE5GE9&1Sx5e#%kYVMBRRdy_PakUd5cd&@ypD;cx_re1$ln1{io@=AXg`~K-W%G7! zezyD#ifD9@H1rqj)0u*|bK_`i{Gs$MOjiHH!;9Y&bZ6`D@NjnI2@(Pqbob>#8~DDI zK;tjZ(Y$f1aLKV3)%)j7YG@0GD`iuxtAfQG*o_gKE5P{FzGqtzu;UY|3oQK(6f$JE z82v+vZ+4XlGw{<@tL7=R{Cc^qT;j@ZbGR0AI8!>hyHYqaOYdY&hsVjf1E7j8Yg) z0{lkvo3VbZlG-~1i%FW@9l&XV0*g=R8N0bhgL^V9GEA!Aj-&ac3{uy~NY&^O&-u%# zKEaP+ySMG3qJlefoEVzy9CN|TibQz$bHs9Kj|SP0r|;vB8;Fnge*9v)6!bCri(!oF z4ee3_ppi}idb&C;%ZP>pjR1!*k1gM@k9zk6Jm0c-ABkJA9aK69KDJE~^HQBi-Bq-a z4dj@J9R#(7IQI9*OziOMseK!UWt6^u7O9?XS}w_m&Vl)3H6dSQcZ_KCQVb4<*{r)) zP^eYAzJYB0c&yEf!iXJ1^G|RPqf)6U=@XBXb24k*C{gIP6 z-Hw&oDKg6O_h>^V0!!2jI$4hJpalPASrfj(@y#8!X+`!bWHEKQU=!e!dodLQ+g7w{ zfrtQzGuwG$&3Q0+1Bnof&E2GMj%SrL&aYdd4$8cN3AKT_Xr(TM;1LSy5jrf~$K4m` zB0`^qUcQ@U)XV)Bs|UUOmUlML$Ao?Zy<#`VvX{ROivc=@^b6^JM|S0l$rrb(C6P=@ z!U_C@@nxx~5_sI9U9xP;9>4U=C%x75ct^>R`)tDNOYwJ_Zhg1Hh#c3w8*1qX=lM=2 zk>^>FE%rM>H3t`zY~nIA=U~h|Urb^xWE5?jic8T=&kZ6G4bG!+1AM4j)_fW$R;M&E zQEv*B)?F#R5$jHj?V5jEZ16Hja3!o_Vo->?CZQ*b2w8y2$DeQoWmCGVbJYsVadrRG zch%T#OwQpkURb+=tmbafo^vLN@4PD;PeuXc4}-4z-jZA2ab@F!gG|SUZYQ#9g8O!K zX*HK^*zKG~_UmI;y8*e}*b0_T{9N+^PVM{suuUu9SJ5TLGhUeK0<%Z; z57!XJGz3ULbJQoLleY~#u|>w4P2TdH?}+o)_~FM7Nj+e|i8qwu%8{QU!!+w2QKQ}| zF64VI^F;v1)qB9OAM&v^cl{Wpiof3WlQ5M4ko56|Y<#VB+*^?0{B!uxQ?PpEU76os zQ$3!1T4JD(OVeAU?~5etQ+VIo7iAe-K^&^{@HEX?ZEI zFJ{@UyXD$XcY2SJJvkXD(&&dhhb_WQ`%*Gxam(5%`3)$>PuA%DoStv5Tc^N=TZLO! zPgwebv%lkXtWLn&OyV!SkYMv(1Tci=*F2rTYcNTgWqUpKg8x<`)ocRU7Ke2M8o5Hn zU`D!sqe?*LG&Cvmh;Ylq%w2x{h&2OBj{PeTiE?k$z;}8>VPgK0x08X^cmdmuZ{o8r zk6$hOJnFD1HW@|&+4TI8@8>ECFLW8Z%y)&p95OJuD4d4L-_#r8kZ8{h>@ET)uk&-8 zqp(1@Y|NZ}w=KQG{ciookK`PuR1P@8^$E_4NW>Rn81I}|v3s)hIyHjL=pc>}r^}lB zYiR$;q|z>NcQ>R z6q+XF%9~4kT1NbX*-jJj=k7(Y*%33BTjo_#lEq60+v*bgfCfNOC*H+7(0!5LvD{YK zv!L1UIFWjro0#EZv*KKYEXDm>8LF-e8x>!KyL?zJJ`F@~?1HNrj?FRQp;BXV&fN5<5yf=oKjprzr<0Pm^GcQE^MBsUH%L6G(aD9Tahzu zN?1cSx7I&s>KFgl84=s1*o^?%((d{H1!+K*zs1(-AE2gLT$xF^fSF^bbUcAl~9@Q`zuC2|LOT-n8`vW(%WD zdcK1Nn`vKXx{dF&j-`eLA9;b0zFP@vi*NA0CSNUST&{G&$Gco9YJY)wrNDf<8s^FW z6U;a45KG4H={zp~l~8*-HZSbDF`UndaB zzAoE9UKQOjB}bLiZJX+O6uv8glIJ6x3i5n2y6;NodAngA&=u~)_!jv0pwjPbiuEvX z4m?;-4|5hXam3^D|7q=6p4plt$O&nd%B1+JJTd<{k9dGIp@hcQmt}{V8Od`{zHqsN zJnM8eXbKYqvu{b2mmmCUPIqq;_2)tHWiouDH?HlD`!8M8`hvMuXGQA^T-@W0<4IV@ z@U<_0#e!e&4gQU<7L=zUJTpqSdkXiQVXcyL#G=4nw~~0hKENH_Jr&&>XB%$bWmH>u z@^ljJo+@Y?OOJKP*KnWmP0TB)0mknXj%OCY7jv{{*zCfK)>)P{a-@}7PF_7PkxT$K zUF;heuZMKsSpc+6Xj3z;`GnFBE_X^V^Zl={U<>#KcD|SsnT+J0V+@}7K_veml%quc z>DF_oGNxJXto;R47i?1>3?dubfdS^_w6-~iWq@H?u@&sgJENQ~x_1q-;C@<`S^F@7 zaUsl^CL3~y`M8Sjm@Oem&x(@b?wG56O6m_uYLpMFhz-#iW|gdA z;^Pxc!=JWGNkY4_EVdF$x=yJX48wJ#|F^Qs%e6jvxuO@MiDM0#$U5q3+BFE}sK9qb zc0SHX*A%5gC`U;;j71EV>)3t=*o2;qYX~P`qCMA=t5)-~nU$4h%l%MX&k=mQ@OmDD z6}`VqjHq94?6aWOcRdlkR|uZ5)jefdm+7+aW)GLN;C_~@S9%lIB)Jyj8$d0ugHzy2W34E_3DY*ZMsA23Q*|$|+#mHFxj*WkN_tMZxIieH z_gmQh^}FED6Zxj0APx4Jv0?ZtZ|7yn-Bd_9QivB)g*<*#L>c>TtYhqJX+GF$O;>A) zqwKJZof(;o&Pj-%n=ck)kM$yTUYUBK)J$cz<5=~yU>G@95pzt)#m{_Ii<%@Vi0@Z= z4dneK^0so`H6JH0cr5G&Z$LY=+cHm$u-Td|Pd}vs!~9eg%;=#IHJKs(z|&Qenel?i zkYY7&#~ocaqTErc+|f4QQ9H)wJ8H)Y7UO`$R*c1`tFRbVg9UOA{IL!e1(je-qXZ*W zg0YPfY`z|7znf5x3923w1@lS3d~3%1Gn;Kcq#ta(6(v9bE1On=KdV z2VVS`<@&I_w!VjQomSx_!@xdZ~_QFW`|wnwYR5vs2oaqqHxZX7zwLauzH5GhfTO}kA;YQd@8>5JD_7{ zY^@3&s&j+J*p9Sx`@jb9an7W)Fh8)g7N&{U8qKM?TC_B4(b())oD8MS-H5X*Lw6!m zhK8;!seNnV^Kwa6_2!b{IDqhTz8CI6c;)R zoh>Vv()QC&n*s?H_M%;egKzB1=tUL>t;WqJTyaO7AVgXrOmfr}F)TCT4D%fV%t+%v7I1NKN_r6X+Hze=@C7P_0Wwl zOn)=`fg#_{*OcnMT`yMp?jd1$biBqkvt4W{bq24|J8?FwFX>ySUyZv7Yrs?3NY=PX zIsGRYtrs|25r|NZs!;?|?omUUV5&q2!FFRImWu8ur7>;Y#dL$-=U%3D5H!O5CmSVi zi;{cLZwTe6;7e3!Hrms1u1@)Q0aI=eZuVG_+{KSo%hgZOffgovc}Tv^waXwrD4uZ> z%?8}ASoL=FR$^Zo>5}K!3@9EyMYdO|oD$J)l6B2@bDa>%`xI0sg9#YfWx&N}3*tKp z)2v&(hwoG}nng~-^M#bM3uw#z^_A10augk47~ePThr41X_xMcTy*y8_ZGQPQ zwv&&hOKtF6My7(X{AC*~X`(7zC#gj=uSeAldO9w?D<>2q<7KDMV#8 zN}p}JReqX_`L`&)BeAAJKjOxR`?Otsu$aJ%iZAzlk#(g7do3=nzSw1>-UOx_CO8iYU9ApFAy z;p5Zw!#~j={E`OYcQgoptU>r+8ibF^)DPdKLHOYf!q0CIeqV#|R~v+n$<_})qCxoA z8-)L=LHK(O!pAh#51-Z`{O|_hS2PI!NrUhg8ic2t>xb{qAbd%K@Xs{}f22Y9dkw;~ zE%n1EHVB{7AbeSa@J}`fzqvv9%MHRu4XYo%cZ2YA8ia3X5dM0D@QK6ghacY{{BsS$ zpJ)*Ner-7HxF06o`~Ymj>#FSVJjmO6k=?g#PQ4zJZ6AOHQ>z{ziOe4uuD3PfcYacZ zR%dVo;H1~$8-on?frh0z%hf6K?H%4alBajv;HyA!Uz@iAYcw#hU}d#>q;Ge5F8>kN zZA;Xn8Lv8jn(b+R%=uU7d8=xd8^ToE}-3+=d`@p^rcEq3eDIExaXdQWMfi1|biQj0etB{~CCls_-~1#skg)zcC)C z#dw@%;BnfP(NSd59^r!1CBGqDVC<>Hf#{ifJhD{xF}W*a7^lS+ot*t_aD^zP;DXwmVP8c2;w^{%2Q%KKtW= zwoKT+i|w%lHeQbZKZJdO&1&d@VOoamWo_L4kv6U`ZZZyD0yasn(na2RCi|FrVY62HTT4Jly8K*rT)$8_39Yts%$fR2BxHvaMI_$O-P zpOk>5DjtXCR-@Pr_!Ogj?UB8Q$7lGS#ys>XH4l9nm1KEU%|-|qXsI_FeT!!!#0Ml! zPP3(fkxuwi;RsepJn zsqj(hFNxC2Q(#%$X?oZ90$nRxf&GjfpGz8Oiu!mfyL^$Y&M01_<^miz#~GxnE&V=T z8IYXP#kSsez>{LCZ+w0b{s< zRS8E*Lf$tB{^sbTrGJISJ$xVEV!S6*{;KY)uiEk1uF+AOJi>bV;A?0~b%^E{PIP8| zmhJRkfx_3@O81iDSDT*YJsE7@I;+PJI%*?kV2p0HjKj9g@^l4XZ|%u>-x2Jrelej( z-&^x_(98w^3BO_VxzFceo`Vb%J;c%HwMOrn#Y&B+d_$?B^d@WLp>Q3wI@F z7g_q95Tf6Uc&q8>(iV%NG@oM&$EVdE18~EuH_!9lS19~iF1o&$60Te6g;(0~Q%qTP zp%>!#LOk2^!>jD-3%%sdInLMdWFdN&XEn?q%;HhDKA&Tk5y98$+2ZDVLHjQ;_D=qQ z$^Dy{5D>~y!SxWGzk|JGpj5QEt!(kgx!OEmh9`AR@zV@1@SP0p+0vL+K3h}iaJA8A zstk7*#+Eo`tBz^FxUeBL=#9mm^0$~-R@QRSzK$BFqq4q4S(+BhYq?LpEwtzSS6l%s+-9rdza(T?us5xUDo=fKqslKZg}hM;-*8GlT8 zHM$Q+-Q_mP{&hxiZ%4%;l%uMO?6sG-HF^G|HZ@C76DyOALSLOF^J8T9yx-T;#oLB3T#iLzbP7~K=uStGLYhAfx2 zZlyZ+037zSW5fT^;WbPwI&4Xuu%LBlSVx_(z3PM=W`v!q?svKtqQBs_ft(|cR=72c zA1U$c<#-ccgXT0mwZ!|D&tga#zt30yiXFh{{>ypvbntI}z}K=>zHG@GxTAP4;Lkiy z1_x3caVD?(M$Al1FMQsp>+8%Tk%z@vr!|3VQ8L}Q4`$$SJ*O1(%acyL{*Y%Uo72Xb z5CsS_u5792Tz*<<)mSz_Q_&D%S!~q-ka=0oH4*W{o1nvB*6$U47Hsu?a**Se?%-cr zKSgZKV81*?tmD)(#MYVZG~jL^Pw5uS+VK;_w@M$*05z#6h_&qUlGu;m#>_a9KeDVl zd716uYwiA5$*E;Kyq)r_4XE4PwNvTa9)6z!3K5LFbv}{TE0BwSV2j@Q4x9H2?u=DJ z2pO1GPhu7IGvY=4tgd!xnEobCkNDtbat;(D3HMdjC?SUHqF0kFp~S(}FU-b^L#*YS zIuEE$tX8gLYCuFQ*d{iv?>nXy=1GiG%?qw6Ax}Z=4!z(?wK_tXEHZI;=|dWcDO`T; ztvUu=V-rrOruo8)wA`8E&--h_a-_-9tA}c5P z9>`Z=qtS|M2);sOTDljU`>PoEw}N!OhtF;J+>X!pL2K492=1jzK;TJodjlgQi-|P+ zYrba8#+{agKe}?r1Y@gm>p4{#xqfJ>1V0kRq3m!D&`(d#0vfc!r_$l*=7Ps;< z)<{ITsf!18iI!v!wJQB(Q~fPnJoQ{}OE<0e&;Wg)vxu_cc7Ii+qA2F zRh4Lc3LEdYxbCp&iYnidtg5*+Df70eh2No%OobY!sLRNgP>@RFT{xBougctA) zbsj7RDVbjTVIBOgkuJO&3*ji4ygNzwKP~v%IY2>n!}ANG3KKSM+VsibUW+d!+7%0yKQik@q{JNo@oAE) zZ0H~Azt$MGJGd&t8iaC`f_P+UxnjrjbmP7gHKf9 zcW3_w1HX<4KZJ5rz7QN$gB#JQ^`6|%H>VZXu-cWq2(s@~=F*Q_=*6S4zTmo7BV7G5 zqVj$jd4l^m1WpNGQeeGw-*0KW%elzt#=l-&p^PVK6^NrFEI(e+XeR=@y9QeY^cbV+ z(cTiyVg4O`vxn-Nd2!#&Yuq>UhV;#zG5s(I{szlx%e=GyI-`$vjQR+n9F@-p%Z*HT z_Fr$L-ziFuP>w1Tf@7=t)aHGtf3Pltmc}-pFLgG+Nn;-asnz12UOuQ%zD7du!%G-B z&%E3|4{2~lGGm{2jdm_WJr)hKoV9>An8!EVsCd^=b;9%fer%GTZ~UjW8@0$1AP+Z3<#L&xtJM@%fndc^!nH@Ok=Nx;ITZ842+6;S2at_rOV_7gc-2 zGMfBm2nqaY|9xr+?(`z>?S2|fj=&_gF|o`<>cT{7tbdyR_W2UxL@G| z=B-O8%$eMsrhqBYt%C_%rAF&suX3{$*|{Pg>h@uj&+YpUCgdN&9LaV(BZtzjArWCE zK=!kpzI+>{zaM%h2|LM7E(nfxl`7L|aozAX^6`BKC)s5rQt#s4%-y!kl@lFUr{KNE zfAJm_KZ~w9LM~On6&C{sYPrFd8@aaup#GQ8-Y+u);iEX7T*w%{LO~mlrPw#A4V#lt z(!?;>3#mQ2JY4#(e_ssRBi-n%^DVkBZn5WTPHXNUF`DDU?SSrhMMC)>Mp?GT#B0_ z^gi1y9YRFn1P9RfkV0{m!${lVn;G@4vefG+B?iInAX9n+(#maUp7~llD#I&b)P}d~ zHoRT6Az{|u9$v`3GG^uozOVAXqAOVE8jm?}i@io=hi`%`-eR2v9w79>w;?3k!Do@2 zIFLFB;QHY^wt7P8w9EJWIDRS_UW%Jxo4&6vZ`B~HmWmBmr<%`xXRSL*XqE!MYhwUAEkb7P32#}@x3>^I{&L^x$U zS*JjL@^a+GHaDsh{>4_*fD;xRln>vP1%9_q^H-7cu+M_`kp?k$v@f)|)){YL&q&3O z8^z+6r#%^o^SGY;WHs+4c>L_uLOEPy?iWBKnRR@55PBg$2I|BD`@(|O{qbFtcf0D% zxk(l+nypQkqmNVPC=bH~>sAiOk6k$wnrp9&K%spcwJAzKOyqX>pmxfs6CC63yR8i? z`|6a;9L(f3%)$99+GM+-a{?MXTk@PN?AI(y(0jWf-B{QgXw zU<2Zc(4E6(G?Bnu$ECcLQ5QlRe%y+AQ`$h(HQ^1nO}yQq*lL-CQ#-*=Ep?Zw$8Vk4 zD7zX#R4F6xvAACNK8q2GpKrysgv=N8YfV1`XT{n4gqj7byCHa-<1cI&{~E_%)G+=% zeh%YNy_O(8e4pmS_eJ}jO>Ecf#O(-jrCA~T09=L*L~O@wn!Sk_@!Wc(Bf$QM+aUk; zlE2*m;D-BTu_{@Oii^J8U&W2^A|>$|bR^3|o=I{$=Xprb#0k|XE?Ns+zG!U&exv<< zSRr`{UZ-Pbdk&Ms#F!>Pl*1Ci0InzU`4p<}gdZvetH3DW?ncW`;2plI8YQGgs~Ots z01SnKZ&wq}zFEG@<6oFNh_TB+ZnFK9yC8Twp4lYeT@3QN5WFrq&rTkl1A2))M|%ky6RCLJHQdgCW%h*Q!e3i8QgZLb+PTZ zbIoc-`BJt2WSFuT-YY26Z^}1!!e}9tzUEs55{fXY&RLXz-=0dXTiNka?Ht5YPFu1Q zvUV=XlMbsecg|`#i98?y8E?==@_h4zoKH{6`Shfoab&(Z#MER$$vJ27c3*DmN@_~s8a-~3_3H?w@^LiqU;0MilW?f3`73x(V?vibW_#;qpSQAADHVeM*c! z+lK~E!Z|#uN-0SoLeIg-7&CLM^{E8z$-IH_Ot_;1SG%`D`bz-u!Dm z!`k=Icj9OJI$o2cVamZG;u-KkJNT;$UAt=kv;#UNO3R=lX1^?Cmjyaah!Qcr)eD;8 z^K*V%sx@V|rpo(6@{5J2$^qo3WG$3z`he_ddV~2hqdiSk-Y`dW?l?C zmdRyuX=<1+$~Y4lBIl~L#*o`BK!dvSFjXpEN@!skL z3M(ZnS*TdxH^Xtpz#1O+?GKqA&@~yOiL$=xkX}rFcoAV5*wA*&hAt!CGvDProaCZ@Jzp89(vlR(a6f6%rwOqyr^+{_9Fo@C9reVB+v;%T7Z%!F?%ikt=Nf5!^ixH2Z8G( zONU~+e}sc2UcPvNO4nYKF3f|3eFe$C(SSN#1bJ9yRAcczu^f)bY}6r!2Mnr7}2nz>8U%w0k= zcL~j;`5o#!=E1Nl8{ayq8l_ulbC`9w$J^@-4(-ral#XcS1=8gz z4ce*yP7Do|q_mV0OkQ(mtVer5xA6nf9O_wf>35XK>%rduXa+ayEBozz-` z?9U8jod{Wka#RCk*_P0;OHEl>@6MNE)S@P!iJJCGC^{DqYR!qX>N6VzMg(0P&U zpHae^wG>ys>E$qM_~cfRZZ$e&lE!-(@@Q%p0Q-D#hGU20vqDDH9^nMl9z^V8`(Eo_)6+6q2l)FY-9V%;auBR5(+Wxm+DK*}Xm5Rf+DhCcd}> zk}aim6u5}(Rvxl=fA<%b+`UnLNa=z(0O>j;-7h8GuXMU!s&v0nzYlA^@v!0>`zZwq z-jc~wc4F)zy>n^jD6o1jXy0~YFNos_cGYi({D!kseYJm=8h>YvzpKXIUE}Ym@$ahq zv&8R&yE)p9kK ze_Sm-$JgMqqPo5()Z{<0#=o+fzD}ya_vBi9PmzFk>=Bhy!2?EAPLrR|(Wi3Mpgq_e zw5KDp9iE}aD!gHzf}P>_JUFblT*Z~>qbIUeIvvdyReyQouU-9aX_|b^pDl0ttadO- z$gcG)+u3kAnCO{~rO#>Lgy2>@PoCxQ!@6fXq6gvA>~;z_^-(LG>nP<`N)#Yo$Dc?Vn$l$<2f01#fJL%DhyKL9RN+NZpQ8x>&jAxRxEMd9lffm3k-fULs;yi; zuQQ3~S|+(mxkK$T=$UC-+wFGP;X0!^tfh`!Mtm5(&pSRU(vLl zp<33fD=B zK9oEBhH_7_M=Gr4p0n^ujdwHeD@=}QCr@z#iTEbyrbnv>HFH=PwQ(x^7JZww z=i3er+WL5u@mvkEP)swat%fuVEgEkVDmO;=2KJeVWuxN4t7Cr7{%e%~ zP9wc+yovwXxCyT@nh?BWgCn*x*EyEhHRFu>6l#-!%cEUNK9s~uQb+1=A*+n_n)P~M z*UF<{(EAQ~O5ep`L$D{Y;SG+l4wE-^r*2Uh>bgKKLM@5~;*E}_&jV#x7ZfnBy2(*C z(%2%o*-@88^3KyOjy_D{1-CltvdDba=Z12F?@>_GXuFIVFIBpY`!gNh?&vkydZ!EQ z+htX(8-AZ6c<~`Or*ez34bB*KE_qw*;Rv~Z3ZFt|;|L~4PU;ShKwy68dlGGJ)`)L` zMrO9~en*k%6IkWv$WmP9WYFiX{B#l%q%GmbOeOWpL~0H-IAuy#09BOYtf~^yPY?G0 z0F4g5Y;@Bd6t)Ht9BXqk6v8_r-X%JpX^it-%nBlX(bq)hgV2;8JlRNJv|UZ!v0Iea z<+GyGjl8nIMvUO@nD$mE0#SQtrF%e0(#6$r`4LrdMCA86YMlwa5)m3tkvzJvTQ zgUdz`-+`l3Et#C*bXdo7j})?EA|S0T@86;S&A*SkW{vM>^eor~Y|mpsmSp!iVln(f zAW^wLqGyuH?vF+UJ0*?gr4K}XnzW!xp2_v&EE9|@KVtABdSWnM_+vdb0p}+XoHU=o z+yQWC@%tbk&5d&LEe+xff2tU4J_<^OKV!&0hnx4FI$p8cxi)tAkfUXxNj6U8^7I$@?}Xhlf9)GT*~lC|L7%0IDJ;$vKFMK4>#*Q=;0H(@{2s2yqIo5v zNATaBAjFG$*1oc14^O}kux4YN54XM8i^EKg+D<&wE> z+$_o0t^;OC+Q@%ci3Ct@%`?b|!zybwTIx>LtW^^BtZhX~e*iE2BibZc`4j&*h47D* zz4DC1UAa-Z@>%`~exD|Z`F8qLo&#@Y>zy)ZFC%@pE9ERb57!HE;NBEC{b_wpzr0b= z0w7?$h3w&r@tCdrIT~vjJ}bHl)8HR@puXhrv(x359sPoqM6_Bo8q2Ss3tz?OHTq1> zgs(eLQI+3__yzX;aaORi7N+2;V1%PmMCefvvah|CsB@T&Q?Qiw&vAqsz6Fxp*2Kl- z^11Ztv`+XoP*L8jD#B&ptqBEO0r6uXG48nAr;BmtrX3AD**S1+WUx9W3grICkfiV` zmlij5lb!PXLhugQjIYPt? zlu}LHSWpK&)y|2*5vYSdw58qfZ|H8ZZ+H***pBBW8U1M7`4%38>`CBW28#PT#kIJ+ zPbN5dOp@|+ry%L!VKG%i(!s^~nSySMSqj5(DHtUKev1W3dDkIy;|1?Wq+UfnF#w(6 zgIaoU!VeApiS_DH)roGPCc;=Ev#z<@x zArbypwV66+J86b&?LyCvE$P`@_MezNQs?kCK@~1jO@|yzT)oN@3`P&}^;eXB{Z;jgG)3UQmA(3U z)LQJl!-FteX<3o)?%qe{uUG73JG)hh=SL;VUQyp=CJL_$3a`i<_8csb+o3XS?V+b~@xN-I3BZ{lTj~@5xG}OOZGYV)}8EpVGaKbdVF@@S{7FI8D;k zbD7I$BzK2gKs`u&BRrZA^5n@APV9u9t9iZ7???HwY?rzR@74aE#Wh~?d10E8uz`^m zW}=#~*2f8-;!Ab9Aj$b*)>Q^(e%Rz%{2;lRI&acC#{HgbBet(+=|csQc=e64ZdL~k zh9!bKQ*8Zs7yaN}^-R`Rk$yPL#ZwTn#8gICEaUdM#--v^?XFr=%+g&x!qqx&@#kHo*Kt{PpT}#UlUamhm2)r%x=*UN zIp6i!%H0j#@vG0O;eCd^ndcceX`^ZhyNOTPG9W)JpjZ`gvnV_fkqSp5qMdP8cRrQg zOX)pK2Sx$xBmTiHTRKNNaGo*J!ckJEs<6>@!p7*j%Q>Ze2>%v0xSa~<*4C&kZs{tv zyDlobY(!J#p`ydvU`PVh7{3SkkVG-4hh zOfx=DA>32b4(f9N(PlKTX&S$l{MgVxPN}Rc{L_biz3l zk>xuKZQl#d_dvqDmV1|k-iy3w++l9QI_)5)832cw{=brzJb`O_4h#Ch1xzzhf`8X0 zaDxjyeU=0Cjms|=FwD19mLeh6Ew^oPkmHulf(6?&p2<)jXE!Eur?7bP@C4T|h6jGS za0onQ!5*Fs!=ofY><7f{TvINW`EU`>z0-M!%3WtOWQYPBiN7bKqig}nS6floDd;tT zR+~zX47Ed1_JqDQXP$mv*kfJQ!HnzM3fJxR?Cm-Wsl`}Cbb~7(>lTV^@2BS`><1hI zy{+(r>mz=Ulz@BU0EUwBg0FkA@fQkAhBIBQ$(9hRprC-}O1izU^Da7~o_AUkM8aRg zM98PQN@v0VsZ(E13DBE&}MK4AHTqfDR5X#&IF;JYGOZNZOf~jLM z#TYn#a3!j4`wD_I1qsH@$+WV}M*052bfjO$e$-*yE~25YD%q^6QF$r02kn+z{Z$(5 zonBl+zgt()Z4bUwMZ1v44p-+zXgxq{`*lWq4)+&Xi?Nni;PT6M$puUjE!>e1ggy`4 zk_)#N_NkKe!A~k_))sXrf`%jU>$r(>h5$cq%Ps&!`g)VmMffBp0+Mr6XDE zo=c{ZLPWNcO9q#d3pjMb?w6J?kO8JhZQGKZctOtPs;Y4u4klywrX+Ibl0=_5>huMI z3fK8XhuNXy_H2cp@(DN;Kf5&^${Z5zfN3t-4KjeSeX$_CxCQUnTT8g_T7}}!q)Z%B zm1rtND&s`UrsWfHG9>tZiYbGH9kv{I!gE^r-U%o83PHeO+4I1DaTkY|56>m{@Pv-l zFn*BI?r={8I~BO8U@!P8{1Goqv+dzhmR*=)v@GZ*%_E0yu%26S$Y}F~E|Z#~VjjCx z&7rPQt!@YbF5};gmbKmBi&5`LLRXshKS|UaxKmGoBdK0f(f>^v{5;8P<|8mZIkp?D z)3GNri=B*3133Oa&b|Xqsv`OS&5ILu7iM>vS>i4z*bahneu(Fqwww1&%^B{8y7qa*k5E6(ZmDjLe?8?;P$v zJKlW(z4i6v+3GgQ9nFxVK0QyP4psB4r}o7bt9X*`Kbvgr%p;uwnp3#bKM%`~^%{Ko z(0wq+CPS1o2kr9be9q1D+hy2U*^|z1)Hk_IJ5=u_gVTYYkzAMQfclhr57tTzkWmNG zK2I1q(T%-5NQUDvL6s%X&187Y&1OHw>3c6)OPC!t?^ogGwD}N2B}oy8do*@=ysNh6 z)BfSmYz#N2qXrC61>pqLk!Pvw--+_8(P5f?EgC_4hL{AdZws35V2S)xxFsgb$sFE_ z=C&=i#<|NZjV8B!C+0yhCz`xQFE$bUER)EruL>Q%mRT%WpGX)l#gt5jKFazzTG28) zngdtx9B?b<0I@|KV)g3PH6I?cZp{K~{@b>-9&o!T9lTD$$Wj_@kmrRXKhChTP zxAJgSnyk;-2Sl&ZyD}w+{ln^7HV^83Qk4afXtNT z#^Q>rLE_7MM!{X9ATpsKwH6gY+jI61SZ2s;` zwBsC9(FxC@mw_y_Avr`7BrQ&OX1e0+9E97su=GcGYC~g~6P^xKBCz6Gtl1!(YGf)~ zg69F6JeT}nMSA>r>#!fu%kQ!Ebl|!Ukf42DB>2r{^3$GGVh== zZ^yzF+Ww^T6mH7gFv=hj?)u_osOh`nmFRunho0?Hr_7K{C{>3{lrW0pO{dQ2YjagQ zVsUx)6$IUn1LzHO@qD=ed|t8B=^PbM;<&UhDERr=>5*&=$uCb6_<57g#QP^|B>ccU!G&7k#d8Pljuj9L<(Q)ZjKc*UD89_ zS<9>f3;fqXeE+0h@6$L5tbE(|#J%w|GvgopYxws?_;_a^C$(fsITL(ej5i$$slyic zLj>f8zj0aTRy@GpySRLR$7?C1cK+1MTAEe0mXKv>S6)j$nYEAsltOj@vuRvEkgoZxM1$GST4c`lQR|!1vu%^)g$rBIhwXdlT zzC7Xn)>RjxdW?{+*n7I4Rk}Um>Bc&?xE))3Pg0fdS+g}Qk6)!++^_0lBQ-)N z9E~dTEA-X0PVCSPNQC>gZ{FWEM2kryITiN`^>i*gw7O68@jlJ3*#!+=_+`aeHV+%C z)*r#&Hu%$NHl?{H8SaWYUnz=WLQ}>PkAxoeyjupO9wbMIri+ted?y@*ijc~n_zFRs zGMyCZ9B?*D_|x3vCP|;ka~iw`$)bjk&v2Y9s>$<7$;fmBkU~$E-#&y&Cxb-!aD9|P zVY=vd=%zhM)7*2iGR^d?8!oMAdz$7YkIjHsN;(Kg%CQoZ1ND{LdpIZ=o0or(*nd(s zOMXNjx9<|o9dw7EX|D4iHj~Eznmy~8CIo80>%1VD;`tNJ246=u$Wt#Kag5-R8?~aq z=aIf-li<&gS1r2Df=EO8s5#stkuF9_ycuBlg790~#FZLRJy);E^%m`*Rfcf}&U&PT z-{iMLERgW z&fqhw_7mx-K)QV2`H_qt{Lf)zt4O?#4Qg7z4EcLtleq5T2Qm510I?c`hIO#N=ZxYo z@v3k1AIIv^+?-*{%1$C?NCCyomHS3FpcK_@6Y(16xTT+ba|cZ_e$Z!K&Y1E}AcEmM z#gj@L3(GX!Qc&*}vH8^p{2o!s))fGtNBF?XtIA~7~NT(b@Q(L(~{CQ(PK0S`Xq;g)_Kzx-OICv^%+!U5s!s*<)}z5o&Cu)1^hKWS9pdcW6~8mjSo+S~ zSjtOR$ol#ItIYLYcm=w}DV39WMID5DO4QotRGMdft-3*cHXU8+BdgKvCg{z!OEztf zNU&YJuq7}oyCeGG9A#vOn55l&r$-w;6n$`kEN9lxz|aDZ?*53MkOPY;r?$fTBL;%m z6mu*QjdXGDh`n$TnlvLp$CZvfd>dy`0NJ~eqCocm? ztt3tU`bJkq?g!z=>jADKF!UoD9hw+2=65(v@Erw@5_9EQH60y#WB6Pj-s( z&{l@VyjO^9Fkufop7Bf{p8;qwNKgX`}eQe z?CWoh*`C|?rfOfF+lT2?`Vt2TKy5KLz=;N7sCAqkfO8AK4)k7`CAr55vd*mw(mYH2 zd99O(dCLS!2cB~p7U;>ZNtziLp6{c@0oWRo31#zQoThi!+J;j8(Ha=f z(hi<{oFQ=|cIikMrp+WGUj*QzhMT;?12MNo1@yw=4+xLu@IerZz8B-$#@d}3qD@D! zeTu2J7(>kgH2jb-hwzs?7uh_lc~@Kq5;j5a|Mju`e`}e%bTAqTC`EPGQBA=|ls4y% zKdM%P$3?rO=41LtZ3<&;TAcSBU? z$w8#c*T&(3segfJG}zP=Y2H`1CQnRz|Fk4?Yg1!UC%>{zsDGUA!u|m{z)3Q{fxnWH z^h3(oSUY}$b`;SLKq;!bZ`6*RYSq0D**C&JCoF+|7|z|jFxK6RVpHf)GllHVri3wb z@keaGO|-8x(S-Vwk%2B_5N~!Ima7P6xtcizO*y{57_I6ePZ%Baz=Y0YtlH#w@A zy_$~#za)97Jg5d~sCCLr`?HN1@CJ~BokHV6D32v0JBZzN3?-G$>VLl zpNeE}MyFf+A<)JEnUiQ;HID^4G@VqzPg4*jsArS?BND6M866m71V8Z=BX}53cTpl< zq0VAz0mwp{KxIzXq0%i1%nA{oB9FtkC?f;u&s(9~1u2?%KAabq(0P$7yQLpDx~=w} zF4vrc&Qf)a^cUsY{DP?hG7$ZU{Woj!R2usM6>IWbUXueV*JP6LPm}olc^RfvofJX$ z!!6?bSJk>idWcSzM(GFa*-H-kY_f-@0Wn55%QV3-x-=+qJpTg*pVx{c*rx=Mfl{i5 zJDs=~wyw-agV)t9fs*xWewT&)DxW17GM&4m>4Rc4qzoET1`Pp}qPho~^YrfxALChI z?N3){u~q$^gTjAK91)EfCPiKW=DsW2uDEcRwseJ4uhX3juMx+Q_tpii!lC4~eApHn(QtVvbp^#nJHfNh6Yw`DDHBJ-{ z`{wCziTtzpC3;{n#1^Nr+{3djlwI)`@UP9M{F@G5x#DNIiCr!KL_16AIEjA=5d3^` zi=2+%sz!WEaVHbMU5)tu#d#+Fo*MB3iu;@RduzlGEFNv*@2e3%sCcT0zrRNO;NsOL zesYcYA;p_b`~x-OTT{iy4Z=TaA*74X8-xdIA!Lf58H9&wA=DLrG6)aXLZ~mM@*3fv zwGbML{eiHS{L}N>S_plL`4Mz=V0)sXGQWuSn!9huhX=?1$bp>44n;K;-xO>5*y4+>=9|5 z7m!TRag%=diccy5r@Jv3VjjNftaFqsj=b$QXBu1z)%ome7Ma$2Dar^!NhNr0^0IFD z4CKbK0-O9?Q_v2+DVYt#`Lbb6Nk7XTd7Dz%R8uasO*W?KDOW&TOOS;# zwKH(B3H}?FRoNhGoBT?#2Vd%jj33DS&y=AkNjAvOhH+6wo7lN}^=erP#MHq!7o5Bo z%;2$KV$;oplbc943pOXvCK9Q#h0&$6!Ox0{G0N*P3dp|sxfr8Z>r2-|W6Jfy9(1*M zE|Mpvh$b(iF=b8c>O?$(Dv{wq>a62s_^(RFtE^~8cXBR0#$in@rF`iG;f?YuCj6~k zVqHK_H8xGvr^1_EEd?goLFq#D&AQcnGf>W5=+vBN=C0TT zUOb;98E<(#NImB$LGNE`3VMCT*AKSp*5!R|pzH&PtlxZ;##A!>_wYbQ+xK|7@#E3O zExEoiD3sJ&{tUg{vJ6%%Y0DZ(>FyHOeg#&YE%5xh0pl>LVt&C_lM`+LoC!{Y^4Sw^ zi0{#*TY*1X;oqw9r*T=FDleA1w65<0?)nNh0Pg6X_bjC(E937${01av(sQ6|1#_sE zFzrO%bM4McNa+fBhnIpOS_y{e0LkJ5Th{PW0K&^$T}^A4-Ctbp>Ua44#T7>9$+fPx zxz8k{eWe7Ku5$4Z)xR2H7z8a{1I~M+1k|?uYXQBEF|J4W2K>1Z7#lOjO#s}?7`GsN zEB@RDj7=Ehb^z{Rj5`s&3xECwjIoUIcL45YjC&Bi7k};p#-@yMKL8If#y=2#5Pu#5 zMmu9X48T7b;}L`(#h=H3F^(}F2jB_DcoN~K@aJh@bTCE_0M9VSvk3nSf1U%zc*b}h zfEO6!MTGy2KQ94eGsbusfL9pfRfJdK&uhTgoH70b!0U|h2EuRR&s)Hlz!+}>@D5|V zi|~8+^FA;pGR6l0e8?CdA^b7^d;*L~jPVc-QJ*r#!w7!{jL(6w1!H^xz?Y2i6~bTR z&o{u>k}aqgHBJJvmdT3DWpnxdo1 z+r;7@MSKGB+vup0jnBz3dco#IhuOK323YwGb>2zZi!X`twmSpLDC?2vj!HN^ z)*(SObZfTD4;wvWAA`zjv+|qjeQUJ!L_+cBSooNRO&+{&W4^=$m7_??LqKzeERT+W z=HOV~C<4wjz>OoIIYO2_0G{?^JxCm&@lI4yFXby_oeTf^>#jq@}RaHG31NOi~9?kVuuqYLh&2$n|UVcbK)?#j9K_E*>>2>h~SQLb|lmLfYrBDq>o^f zesDsiH}LB8gKMN8Y|?{hMCk{|(nDs97c`gCJbjb&TUdeSEg3${^y>t+FW$l4*P09W z*pa6_p2I!U%-AazZ85DNyql**z=qAsq`A&H(9wZV#oG|cvSp4ei?l866ZHzzPn`}a zNz9Rw%n7G>T6a@=o~)cH>U{;&GOon?3W#`$qgvK@H?eCX_HKgluL3@#EyYdO#Gez# zPtiH)YSghjH(~5`u}(f++W6w$B)ejQJ_+just?v!Z%ib`-9QNn`dp0n(AUU3mEi|g zEeSXFt87oC`y_ly+BdpG|IXyFZjO%~QzKWOjZ- zK-OB}Hrs9-iS=L5M%;_vKxM*$K-_eRUGV!_Bj2+kU2l-Z8wnS=(Qs%jB-W$iqF^J2 zxj9>%@ggj1@LizZ zh_DbnuICF1&{r zF}F~?kWn~P#+468i-vh*G>xEZfvs8_ELJ=GgdL9*7o!hF+W__qo-+GSoAcl;PKNmF%rBiR9t0vJx}=? z6S@c)E@;h?roheyc>(njnZYQObenmMHr$IDrQ-Ky>sV6`((lcVwtn*>hdWeny5VR~ z-9gOf@AW;V=TUcvclgcBoa!!GjD{6@h0kKWmwj-Sf!T@feG|&A5t%E8pBNZQE(|Db zKxMM+%mVpI;PVG8QCrrnSl9Latp&Dz4mZz=?AI{PZNNFNHyoFA5pM_1DFd`yZ$7Zs_`48)d#!l3L-{wvj~rwz=#ldz?wDCsXq6S+ z6*WnQ3N!leNOScd%RW@94$mhm10-siuD$7Ayl@HTF%F*e+e zhY`Po;!7KOYqs;Bh`+7(_(u@`c3aJUz#aFah@UbP^^BAfRAo1=$dB9g81Szn{54SH z^Z#++^&J+Q|6{yp{`;iw_5^63*Nc4}b!EF?n4$J=*Y82u8{Dq_@!PNKcOVeIYKF(i zG>1aHqhNRLmw;0!$ulltm?GE6I2?>i^8%?4h^hFwO5wEdhGCG{w2hdaB-A;y@%NVB zx}4wctOLO~EEGl~#PyuVZz+%CRD7Sxc=ngH2lE#*8Hf2rF;}Z+NP5X;yBsl(5a+AB zVhfcanKT(1t#C-7 zyYz6_8WQi4b_9iaIK_KaKH6dL;%UkQg{S@2pLd&#D&h^u0rEfeXXnuVWRd(FJnTrx zsBeg7kpfw`QBs*sv0Hx;?W}}si!uKVVdGlRyx5dxK@0!pjLoMXW0OFs>%?t9#jQPU zl8lr<^3KeUG4ggehgA4s!L5U=#0N>SV-kM4Q+~J!1kFy> z`G_s>GgQ3K+KRCcRflG>aq}|WH;A2*dh4f2B&(ADFI8z*RhdRrp_K+LiWHrJQ*_u3 z$D(!;=7*bd$Pe2+Hc+q6&Y)4Rm_1MTsF+0$aAI2o?Vf%hwomE@qw-^i-ugE~`}nId z+UNMxkPMQc_v9hd4ad>_0TY%rIR7UrsuqN>niH}cIC>5xHDexzSx--yf1!} zjO5B44lPKBjcBrd4D{LGMEm0FgvPmYZl4w7G3`R{1|z}u9U^hws=>2?oe+X5hPqdzFk;4T&@^>+*qq`rG@6yLG{Mx{ zngbJRZ)w&v8Sao=m|KUIir77A_LDj~3o+du?-?=I8itvVi%vpLxHXpZ0?-?~6F=c* z9`fEC@~?vc_TmN=x(+t$X`u3dg@2CnGO~xP%t}SnCwTEUmzI^yvac=dT}byf#^7)i z*(}~?&L+AR)jGb-Tq!U_bLAmLvzEo>Xo5xkG}adLXo4=_J$paKQ)eS;(j*)h2NcLh z;htD-Td4D>{@&8lIut3gE5LmiWlK5aCv6mEi5ytS$=}E!KfZ4zptTQ~vSQhzE^Di* zvbR>>@=UjnsW(SW_UP5)LDaDQR6J9G1DIpmpBK;)yE9Cv+jd(eo`Mk!iN89S=Mc*) z-k~*ZP~bKRSS+^HriTxXc%#E|2eh5HuWcQWKfvZzwa#muIB&i(FJaoTO;x+Lt@_@s z>U(O{_hwb!+gE+>Q1!iI)%P^@J(jT#hMdA6~=&b#u6+ z!+N3Z#tTiavqB+SXOQQ<3;NkCK8P=|ITi94elPJJ(L|Iqyn~%b*`26ZIN7I%4Ty=` z9z>e=DNSk3G*dWDDV9dgs)h2iKl{?{T%_eEDx637Dq9?5xB)^RFg`Hh0v8qT?y)R2 z{4D|#?3}n1U6b!3q%G}SUR)LfSZo_szl%^skgG0nRFZYipzCK3Abg_ZCJ$~7?rJ16 zfoOSlS;S`-{H#nK>KgJMX$KgRH`GX@|1VLGTU9;IRwdtNN?ukyo?ij~c7=Zq*ZW+R?2gK075(!y(%q@jEmH~Zs$CB7 zzXAT=6#ico{@>Tc$J->mj@%CB{VpMLiCu!t?r@m9hv>Ejmo&JKBj$P93!ePg6J?<5 z{-<>W`R%u)5Af&M^1s?Fe?TcJhxcOz&l>293uEVvyX^8|v4q!{gn&|1E?3$MRpL}A z6Lji3Dzh_|^jeb?P>LEzDbsmXq@F{tZT-F3Gx`3Qf=)Q!gUz*$0)dKAY%w0os^Ij_ zl)blSs=6wO`f8`0xUb5*c@7*OZK{JNMLsHU_5jQoAA^-OtkI-#_&cxWtASX8Z7Bhmn7X7)@OuvjPB89t zr1lkaztLN3Y9scdPfvQ6L#+CdTGw(XYuF(=99V}R&EW~MLyt+&v!G+SUptRczw|wY zB}0eM{o(^WnWx5J4oQm&)&b5Ud@A3Qmm)0gO!5uSSjN|=)|T;a7CqzLB+7NPlO6Dq z=A9EoRU5hF3P!djRmB-xJk+xmsC28NJL!xSO3WWIX3P{n7#&PoJHq8Qd3$6x5zSl` zWza1j%9DCp!|bq6!b(pf?kVSok0nf$?dN9`s)nlu(Ru6$NLE($t0T=X;`5bX#1j&% z?~$=!X7?x7529CHXm75a7X`2sJlr3PT`Lihzn{VL{nq|_?`hC(*JyjC4UNu_trDv` zHzgWklR5+9v9~89i4hsP(f2!LvU6FwUq*CeG)Z*8pU3n3Vf$2a9-WwA8-raZD&APa zPSUWG656J#LpB?JPLOSULdcNyyg)9550h9(qrTQY!8=dZ=}%Va$8r+m18aiaOnFPP zK`3)MUR@I*7`}~xIi2h0ga^>BaZ0X#No}%k> zO4PVACG&|CfTu^LhKtq`n`O@YCqP!xnACTS;>l+I3o#_fnnr z(g=3ChMiv3&%e-~a0X>dzR2v-fkg4U&PYV|JY#S433uEkCK&z!8|m=M@BE}j1IUF3 zL5JlfZboG1D2Vub&U2mWJaV=2Ft6_;c;{)6%mC*t=oYR*yBLXuk!RwV)7RuEBpDwm zK9+x|p{m@2v6@JN=7*t&+c=sX>M8R_wRGs0Mzd+DnN3>uw5ioPOY5Ge={{{W_4jGf z^g1mz>tc0ih}D5-U+?d!RVC_7CDe4~I;>^2ZN+tvbGHxXE?V7vrkT6XCi$)SU-TUL zi<%>2Y#~qj{=&YBPR(Q-Ra-~sHBq+36_NVGQ!yD|*ICF4Hm0wni~UY~Gmz$G=@Voz z#wK|9CcA3F8a|84`5>iiMyT(vs=mMG?}H8fJezm0bMPbjB39NJKr)`CJe0R^+ZaAc z=?ds?QT4s9`rgm(Jckwun~mVe0!M0G`0$CRU9T#yQB~ig)wi+Rr{Ej-rXS9xc5YZ% z&X}rvHmdsGxazy3I=}Ii`Ms%h3-ovBR^cyjb-(lXAywbX_<4u=c9kNjiQm+(#Bb;C z2^!xctJ7qkpdT|P*_=JR^V|fa9g-9w;4^=KH9pMF6NqVFKNFtjaE9Y!=8upkeDNe~ ztUF+i)1rE6>t4CWz|W~nRtF%DSU0i33n+QXc{XPV9}NifoygeQM_eTry>Yz z34azsMi?%Ve@DGZbib?;IfTlooX)=@{8!%F>7&rWd4-39YVQV{lCf_&Y*YE0vBN)- z3~iX)kpF7-BG1|mb;KAACoCFv1pHWDn<=FX!id2qD67Gga5qY3?Ec{%-5{zGCEXbY z+93I^KT-R-&Lj8$W+<)09M*?tt=IDs#umJaAH%@#&qj``kPg#wTmE)oeKJk`ab6;3 zdpe3I+tt>5#e~jq4dsO4R3+1eVav2uTnWn6!@CvyCYuJcujJB?MBBon zJneRYGm6eqMAHwB@Q<#JzJTxO!eb~Sq#pHU1?UI@k$fLKx?>xD`gOAjlpdmGWs74m z$Nq_iky*5+C#f0HBDRep z*$~otk5~Asgso9e=H*V8^}ZkF+vN)qaJc=6q<$);JKY}-1pqq;?~^EX?(`&A`vcUA zeOI~D!$*_qZrXRJi|u5=&hYSY36mWE6ZnbB^&=Zhd9EVv_T)@CUgmnFJn;>*2N0aj zOKyHu4zTdw=q2|MgcswFm=d)v2Brt|6?mJc=*0v&XE1ZXbdSP5`5ZAJ)`Nqo+)*FM z+QRDR#8}jjcyG%1H)Z^!>dx=r*CF@HVDUqY_6eRc$}h(wd_aOnK4P&BI@;`GZcsu# zSWs{PTkoN;BoriA$fu0~rY%#foUuhJlAVB_i01G)CZST@rnBneQC2PzXNFA|@TwxZ8##^EJ1BOmF> z;w)RI`gxmJ=k({IaO`mC=D>4?dGsZd#n`*4*rJL#g$^JTT;kRCaZHg%dB(@F`Ti9j$AojL7ugBG?P9$h z`8b}PihLYjOq=Lwp4PF}>6e=H8PX4Hu(e-Zel|r|RgQE|_lyDOSS@rDvDJ<6qgQW! zp;@ixD!;??m;||EuA)J(Idg>k?L&3gB~{z+a4!{Ng)NG8sh#oa6l%C0RtQyIg5B^8 z(?_5`o9I1;`()i;>l1ZUrDBhX-Nla8-G8R1?xNNAUp%Fom$vqkxP5KBvD|`6qt=h4 z;H;E#E5*sgSkQ_Q(f6kK&YAD_OeJdCkG=NN%`ilhOF@#A!5zE>gNe=_+-+U;wHm`wi`Yof4eS8kg2H4@YCRRU5+M* z&-v8?^(<-5`_#3ZBzzx#&ITg?^7Ai z?;2)tK{FXgY0K@JvetOlFq;r7>Z;x~?3OaJJTXUwRet7O!|n<`s}k;r{Zr<=2iyJ4 zmF*~ zO|xSzKEWz(%JzAe6vw8>4X&0SQ0L^-**fZ|a2@K%O4zytn`Jk1R?V!#E{@?o-_KTU zh?YsN>(YesF~hct@;1pLsdqj!Xv3)o=%9NkOB}TRIrzyIYS)W#z57h1-aRk2j4h7D zu#vM?o_>vHL;|93N{L!@f!}|H6IbYR_b1uN6^UAU;DG*`9{7N&w1fVKw1;v6r3a2+ zwH|ne>`z)zo0J|n&E}!eY#wfwwK&8`NLWFiKv;@O4$ka_iPXm;%txru6O`u{)K74=# z55k&?*db;O^jz6Z&z0N;uk#F4Sm!`atfp8XPL~mD-ZCoGb3M}c73ZWX$4-=%@z!y(-^WJtRxpxcJJWE?lixXO*d${KD2cpOGq zqvk~O2QtT2s>3Tu?K7!*Dsdb!Kxx+x|LR$hZOHxf{By+lXev?f*jAyQ^3@Sa~rmqlLJRf@a3nh4B= zsYs_NO*Z+4+WLJ{1?x#P)>m9TjqJmk1?jpnp=_HrDLu?#M9%?c$7&R0mVwVrS8H~t zqp31pvU>4HpoT@dm|3LdV3960vcD}W`33d%ll@ez#ry!}Tr?E5^QwsZu`0M9zk>UT zXbawYuKmCB2^Z4Tr>0|twhxKghgv9Rfz~~>MxIEc){lCgb3@rjsa)zSJ80Bb+!-VI zPK#b-{ny_^e|uwDJiQI~>MgQfyZY1XGwO;VlL~K|qmhhSc z2~w^@!u{+{e5%V-1o>JoM|Y(Jfb4{D^?lWFIR;eA5^9-tT;Efci6R-{W<(J%RxoWN zn|gghdy@4Xace4iOm-WF$rraXcW?*)+?leXyZAq=_2!7baqP>O9@o<(LIrvMv&DTl zcU@z^)DU*=Lf`f(|7pmqE`Wp^SA5(ob{D}YrfkExhLF2ZV+&sJq@!mAX7ndce&7m%k1LXYiWBepxvqBAM`iN7V*T4ZO13WR0h_1 z?W{+Iu?y`b`;WQC^auDfLFK}blOzitr`2g(GJK!F0*xJhk&fyu=PxD+`_Z5_s}6DU z;Yq%3PfT~Z^9J+_Z8D{cuwe1so;Ojd!5155Ta8RCk_RbVuJ<{427Jjp`X&tFL^RbQ zozHbKuO3l4kvBm1((bxm{&>@=ah|`*e-s*$U)ffAMlPb2JJR;ZvVdlfPSJ9Ic>ql4 z#?&d)T8Eq7;K^umV9?j`xJx{z!4*9q;|;Fsg|cMdi_;z4)s0m7=XA~xrhC)bhHrzc zVtA8GHqHUGd4}VL*SdIpR#9}|h46G>XxhvQJ5)|MI-|!TMY4!LB3y2yUS;^l5nu6HFMMA% z!%wnjL~_j`+5dkBxZKM|{wkO1^+i&$G90>yuW^}iSOkQ}Bk>J@`&I$J1#o%kA2QEH6JeASf71S9{HWbo4jNsyG`R4! z>WQCZ7K=BR@fhhv2waLknSg*DF;7&D34c`%!0^)e9Z!GjIEk|Xt*=n7Ha{E!b1wf( zk#ko!Tt9<8#Z(M018eDrD^svBW{b-~f56JioC#Rp=!h#Ma8+hl5M!`D)<1JLL) z`XGf)P#8^$;bZh7U&kKtU>n-x+r+F4w*5!n1x4>9_j08c!N9SEqxpt{z345OTk|Rh zZ*LZzi(4fXK23*57tfJ90h!}DOv@O?(E7ZorhMY2|018*s4DHC{~_(6oIuGZZdyY= zF~km^(lP?fwT(fiA0s;LcHP8E{WmkYzES=-i%z%TyOO2Pl4w5;qJ0&1-K#6)__!zA z1b2JkH6%XEkH;3{x3Im%{^M~rg~U-`zmX(F&RvITE%?>uz6mIvfO7UpgmSa+M-9_$IO$@gIQSnpBT%#L4pv5M#uJ0QA zE%cU_NxPhU(e$absx*2lzJXHeUkbS%?e>Wxl0Wxi`WShmoYa2dIn~z^J zp3TTd_8l`p4I~dpLAZ4Wn$7I151oQ-4_$68}<*Jovy?9a7hO!8_>s1W!EdnsjA_^-^+Tkmn0A5M6+8yi2D zn~u?g84ipd?O?Vaw5**MoVw8}lLEoN2CWu5WH~o147mCcn8U zXl_b6;mHw%%)v_;Wo0RdMNXYn(?fA_2hT>eZ{0;~)~UlW<$BB0nHyvb8eF?B3zhDVaO&^DQZr~?wA=x$Ezo4Ie=9I$Xi;q`A?FXpi#zCljpFm2Z$5rzv#lSCuw-KAzX8uy>3;%x2a!r4Rp+?Zj`&ay`IW7=i;mU)yj0J z0`&JVA4QAOfgEd#FNxv1H=*=nsVXQ36)WJ55dX(=Iw!n^<$VuxJUK{nR3kWPYl`&% zo#=alzC%n~Qzia*+t^Vk|AQ)gMVH>!+)La8aYtV2<>>1v<;W}UmCJbCvaEwux#Md@FSk4INf<|m7vNFWC4!tA31t&+DI^>iTZehP79<8{$B)O7mk%3VW zJv(v2`sl;#4>sAhn;`4kx~lXq;zsPQ+rfr7U3a>XF27H2y(gkwQB@_gF)3rJrpDGw z(BN?ug^w?NhkZYd7*6JNuH`ps;3X%~Tt@xUzW82C9pxE~AI?x6PUmMc`3WRx$c1;x zQEA(ZE;GklUO^%VagkV~?|FyxjOn(al-36wovUH%~CLs_oXoM8}q> zW9je2x3SGyD#Ry4usXa=KNIdkxh$hnK0^|c1a?1|U>$rBB)HCay9e3PR>T{z;5)p> zi=GJFi&fwR;e8%niuLMpjpuiR)i#=W5Asu>%0M`!!gFo*zZf0^h8Nl8$dUxkxVOlN zt!aEGWf!PL=_fi$P9+p zk;tof=sMPd;dOPkGafx%d}YF)s_z1SuxpMM`k9x{`I{8xhC(*ITIb?Q9?#1C0)tW=BAli(vB zq2NKX1znG_3{$S*1oYPB8RjXPzD_QDS_WLWt0vuq%6OM6R{fgV< z=9;{AT;0G$7NuzNVQ{wxXF)t`%(6(ZDabV?+t&vm$a2-LTe));m@b$;=J&WN3l%hmN4qy4n7}5YB{R>Ed zQk1BZNTQwxTFYC&7UG}H*u(GSJ=|KA+qHTRud`0eBh^(Y>_F31XojEvbj zY|{2U+n6iXIuS1UI@_Ms0&-5}6;x zjV-@N*U;hnTu`~gS#Ka>5T$$H8eWZ*}NR{tlRvi`Gui zv6}=}mm-a1y-*Df>plY;wqqQhPfC314A@j0f}7oO5_bSl0_*m65j z;j<4&{&zV|S^11vs* z5#|rb=|_*AS|ZvvI;CC?|* zPhCFpQtx<007U4HfIpr|vIv0E?fr>|N%~-N+~N7zeeF~CmRSc!;;-U&{?jYJ6Idh1 zFu!w@-O_7crF`zIS+;7pYN1GT#C{e1toktHt3LF}pTy3nv)ntwI$sOrRc4|--cQr) zTvvl{=1U*MVf}#5{SCi=LbL<5Fa-RzZcqYNPU!2KwFA2Y&`a0_X*kQ~bZlycS#()D zOjSsN+UVnSM2${{O?qfa3dUFc#1X*fAQ9PwXqGsm9ySN1gCb-5<0eus_wykqgM6~l z5jh`%GA>>2Na&go5}ZdSuX85Os@%bA+R-0iZ9P}p(f_kmSixcQp4t&DXz?(;>_N+& z#S1XC=&yo~VHhJ@@TK0LLZeFqLs>iOhz6m`~ zoP65PIm>;qd+d%j%5Qg_->W*mS5+rhf%5TUNi{Yj!TnSMwSQsI>s5HU)It{Ml_Hmp@-W_g->EadQ z<2U9A%urN%zN_x0HqYAd*3Ozuca^30>9wEJ^*FAsJ3dXom2Jm+@~64Z7R9tS`bxpRPW$!=()y$Y zMjq~iPNZyb8*OoD8qyuH2#F*kVWn7-GLje4m<%{%3HCa0q|xc<#teRgk^3hWQjxo& zCJMq`5&I^Vu}`D_J08U`fdtbk({W1)b&w<+<+o!8i9dqj8w?r)C`E}rk`?CL-(Z#h z0d9JR(1s`a;u!KyEcKs|x)rGbr6`fbF{Dxc!2yR}%H>bNy$4*EJkm2~R~S%c<`+dRXeG0ybtpfd}|Ka{%kZ>|g29aV@)S6}+5 zkv&2CT~E4Dl7@#XxPuO2POZA0av_6{oSdynU<_#NB-r>?n{*`|kWdrIz4>iQmfs2V zOiw63ZtZAL&rbTYF6)oG8+dLfis4Co4aSmg)3fd>|6|OYwXn&ingX|Hs!p0eg$~T} zFq~7VF99H%3{RA?N-&bjrt;Zfc{U|BhX3O2Wa1g^J8;b-Uv#P|#u?qDLS<994W^~s z2GgXv^Ezy zZHHgU&(hkyzK0!-P^C`T)RECyM|9%M?TRib;15y{}>Kn|-RzT3gX%TO5Wg z9K8eMY$lF?a0+6jusdP&R+FUnJcstS!zDubT?hlh5w!Z3>`x;DkqSB2ORm_8L@F*H zE2(FaPAV5(BO9`uPVYgoI9oPlImuXXdVegsi+4!YySpr_<&>Gcfwr!9zMpSxJKyg{ zxyqJ4)9=>x#L>LZb$+1R`hjVyB!hBU{FdG^(K1SVBu?;10O5!0U_t(em_AxW&rxt7 zd6%j3Y#3B|HVk4u2zl_+X7Ep;Y@!8MmlT4g`#3x;Nkw!4COFdLV3WV+Z+7J>fX9L) zPdAsQ8wlV4UIQSQ?((dk_vD`zTO1{OfMk#Ivww_-lAp9n46o!7Kfed~x9N*^V0|D~ zx8h91aq`a$EpLXMO6a}KmH7E|DTQuf;b~nvgel4JSQ)P8D}o%$Wdd@vl^zkK*o)gZ znP^0k&oWQ11W%n@)K9gKDXFX6Y_p$QrlozX@l(k}H0JP!dR#wL<2uWmPQnV$hBB5o zN!J;?AoO78(L6mK?TKt1(6>v@ZVFDgd4}$zp^fgxhGQg#gA^0o7<4^fyCQVCl2!a9 zc%P0;HSd$6I|KYHE|7EGi}YPcBI1&Krh>1TW%$Cgd1;@^yo&6Dk8~e=6s_%#HSFUE z_KAjl62U&zuum220WQa>)?1bZkAqs}XMDkjpRUi%T5_x{4Bdz&?;cromwv*?n)$gL z*7>P>&(GBTexJqj5coza8>PsjOstZ2+u4WpHrT(YMbE>j#_j=}dzzLHmX(GN5hs>eWXSh_>RMbk7PJ1<8f)F?kwIbwH|dYndPuFeV@MG3aQYRy+4E z?sDhaJzd&qm?Q3y-E}Fxm5RLK2 zbbg1ap?pt&n_y2cV|-AQ%Gr<*B~OI6|}TMV<)NnQ@2~KyK38rr(0XU zVD;hf0&CGbT4%>6-(dTY%+lkoO#5cg{S^Gln{3+OxO)wW6+<`(W6BI|U zXDxtLB)YPGB5icLv(_^fGn?X!)4t>b$CIGX()(qLg;oAL+*9Y$Zt*plre`Z%RUi7f>5MC$ zO2ht2Qap`A5@vY4lWKIu^B8H*8wb`g<%Lr))%)S{VaE($Y9p9WzT$vHXtRM-qs>}x4BvNqU-`_ zI_0wIOAyXxV9zN%BCGfN!>n~z=zEQN@)huV%)vHji{{HeCfJ}9UfoWnNmiZ$A?-F; z0Of6?;C48~{s8Q$^u4`~@{Mgw(AxcxH?^(pEU;cz=vl`l?Z74NxJF6SAiS*3+VHK7 z)}a<;#mHMU!c#Hv(~zaKy_Mc;|RM`jQ=q1L-b%gABjwtf%Ss8}x*##V$Un*ZyMZ4J2^d9+tHf{~{;SKd%9Q zE*;Y?&sY-`FW|)Zq*)kKCvyL;0Oeg#SC+@kMi-WMi#m_3^7_@wLjr=EZ0atOq;kQ^$h$Shj^72UXd6#Q)z+ym3*Ck*{u`kog>?HL94g76@m zUk%=yMurO9hXDKf@Et^W$#6dc{Z9Us>+|>Yv45=ul5$guluB_xEQO3?;DPaM%q(#H z@DK6vA7K4Mj>|#Rm$Rz+vYCmXJW_EDi2V7~wX#pqwV+Gr#ALLtRAt8`)J#p552|cJ zGU~Bp)Z59Zx0BQZ`S4&0Q+NNYyE|D9BebYdLAW3`KLXOvI2iJgRqD;i3sCzh9U_ss z{zay{Z7~b&d;x4f$RjKabv;K>(?x#>s8+=UR4;?}7G>&gKq*QL0A-bjzmZTlFCpjW zk-QT{$vg%j+7M(37+e7u0ju7tA=+37dix^QQ75Wq{BEM?kad_+O)TYE>Bj8w;f?Eg zGQ0royujj(5lUk|>qmqSBV1k`YsM>R#zPX^4Jbv4z3~opH1sLR>V6QePa=)h=5P^K z3*JuPgq_N|D>f%p6Uk$}*=)^C=6T-@av#euIZ9?YRT9+hpDH8T zOa!KF=`dO@Jx3cl*9kfo^jvDV7X>)B8snI1z-84*PN>GXyc*+*DnR!y2{Xr<$RAqK z=sU|3*c&)Xdg3koG`Qj&`Rfs7_rfhQa3{j%u-wqa>Uob2o}q>C*H}p(ke_;v^~G1| zN*rH&W01_5&au@QjskoJbv4Y5V4j9~5zN;xKY|4s7DTY5h9x6dO2bkSEUjVb2$s>X zjDk(GI}Fa;Kp8x@|j>5l%I74Yg)| zVDZaOymWq1OUKFJ*ApK7`XWKUfmluP$*y{gv&dxPYoS5UwT5W^_0h0C5v;F<^^IUz z4a-KbMh$C>U`-m<6v3J`tXaY2ysWF5mvuBR>-4;=BN^|ZL_2Ka8^zD0d?ycTBQv&O z3NRGgV?dV}baZKFb$KX#l}6$ylalNNMvU)SQpwl`nKC?zD^H!4^+#R z$WunW!_#1brPS?)B>0XfwfGED5W$lVyi8D@dY9~9I)PZj6rSa<>S%=;-CahL?|eQ7 zbl755noQ&UJDZ4^_3^wXZQkTUBJ<~{pK=-27V2k{m?~$J>{q2hPaVPT|H$antc)GXuafer>9rQn>9i#ewMPw&BM+E*7SH0O6jTt3aE-0Ca z_H8E~#ZXeG$VLxFqnCme9D)8F9P8g9h#Dqy=mwOc#Iu&_TDse(xpo%k<%o4;2DynW z=i}O(;YTKWA&=}wct$kPH{md5sV-ye6;it{SM3^5I*#-Lr&f%>)ehTiV@ZREbf`;b zs{O5~$_oDi+B}D3>?pO6&~~=Nvk{};H}A&-poEnDX_ALS9Bqd$)*3RTf^H?<;SM9e z9YO>OS{$FMJ$Z}f=oT#O>qQ=|JAoUXgYyFk>PcT-j6~I@awNmUWj^a}1*F^81-Ya0 z0>dsnfs~G?@Wa1GXRIMMNi}7jym-sQFo2t7n3mK<{saUlq})$7#E<4LB5b>7d(Dut zaDXm$#YTt{)1!Ul08J#;$N}ZGT9;PsUv%u}LLDB-%{Ywve$Jk6K*R(Nk3+bF!kw)$ z?=Jk2@J#`4XPiwC9xMMioo%*$K+56LdDu=6a_P;j(>XMTfpF=3U<|b**+0f}KU<)t z#s-|Zge1MR8gVCB>Ta}iExo_3743OzYuMUmZ)ZOcWugPEcFYe1Ho)O&YNzqHFtPNLVOZf%{$)ET zqY%RYF`5@)Mg01)_zh~rZy1XoQzL$(Sp47`@f*kD2XVaC`|qZ94kh}_))@>p3za}$ zakG+i*!3yW?MOND*tacoWo*UJzHIyqH(LuO#*rkOb|pKu4N1zq;iNn}LRn$x>zD$! zttfD8tiSH*dv9kkTut!zZ!4%n1QKX0!`4@|d z%<3Y;*{-pHqY8OWvL4=avPcoL12{vX98LEY%5ub_Yxt=!t**m|65ZcK_B-9k`k^n$ zAqpqu;^eY=JGJNxPzK_n4I}i99qpA3mfUcxW6-AQD&Nut#27f?g+8Q=GYYv(pTw%% zd0@Y0y5tr5A~5fM5MC^Q7b60K1BwLSmE4T3#PhRXfe5p z^utT&tP*f~rHA`LjccChd{J)=9j)(B0@8UqK0fz1te6+A(Yy$EcEK{!NzO@yu|XQM z(k`$a8a^5^{Ya9Xf)j}MBqBeX1-xv(MXXP|wy%tY`Ir~!g`Y#B07B32gmR=p&^=7i zB+1W=#s0mi+P}Z;xlqghBS9{`)wiRVT=*4oz6h6hb`DOx)d$l!aDyjO9pz$@?A79n zp^!TUdGI?Q*$G3e_~V;#F+3bC%tU=Pk~#DJ^GTHNSi)bjf5!$DnGUMRv_m1~Hm}I? zwU~{cyy#=z1-QgBo{ao^KF}@ChgbQmyKcex-CcN+YYptW6-hdg51S6|1i%~$Zj&FS+o{3f z9Y{sd!7BewM37a7yZnep-_PZ&!oT6q-;s5`>uz7m^zOkDzM7|nc{8wt-k#h;Wl-ce z{n!N`tX^RY*0NB#5hNv){NTMl^~HU@vMY>0c)zdTo`?q!#CyMgnEq(6&XK>T(pr2F zjb<~=2!;JkD?_v;K4vbJf_2>pl#eT7?efFlEM#b z8HU0!jsuvGkO>5t&Epb()TKG)i=^`j`N>Av?9!9ql^*2Y1f2W=B49TYnBEdVzxp(4 z7h=Ydtr+nXjjpLa)3Zj4>I{PRv`?>$sOe6{qC9gRNl`jqZAn&wA$1 zsNZLGpZ`nsxopdGv9Y4en;_zo49S`+NiT%MhsU>yb@ul zG-^)1s`_cA`h89J*MAhwb#}k5iMAGo%jvx(%KoI}g61VBMf@cNYyJ=kg%$FArLZZ;VE`KljG+U_ddyJ^h7(W-vIBD*O!0m=mBAI z7XlmtK=FL}msJGoQ#pTmDz93fY6+I7`X`sCNU;+fRq0J1r+=OYWd~Nf*n+$ho=HLs zOs?=~P+q4nv%EFVc3ic$eRV>Qd@;>+=wYivI!U&`U(#$I!(sg_&d_qbm;XifNq=)W zW4H~zoXPiii3&hVk6#Js-a2-k)OincVP-5nLX~$pX5|nv+1o@v8MR)Z&w zr=xDydsd`l^rtaK$A}jx6DMMNi;HEXew?X! z2ymij(>$51k5{%h7j@$D*T^KbNtB7yD(EfqJ8IG+BQEX1|<9e@K3Pp z$g6o02KmzUZYsRL0Zl`Zsqi!3i1J^nA<7SbLMEU4n7zb1%0s~y`10JW7v4u1p&9by zOP}rrD65xPXTMt0^had&l~39-l$jrX?US}lHV7Y}%+NjZ;~Qk=S7gRFELmUsw?$k> zpVg~Z*K|^w*cdcpxV7F4t$TH#wc&YM_v#L7!w+=0-ufw-Q1>S}t4IExOLGDJL*18d zUx%{(l)LqG7$u;01%cx_tNiixmS5UNPDgQH#&}eGrj~XZ+D6T{3za1~-b$`sYhIQ-kGHb+r+#h4@ z&TUBg_N}kpo;4Ytni9H21KmMxCVw2y4JXRqReo1R56I|A718C2=$JhIw^6>=HNfih z<>*@Q$1;zrRUTJT9`{w`;f7blFt4q^e4w&4K6lnzds(paO7a7|z`2(;WM%cm_3X|m z)WH&(al(^jMnZOtAAU!J)j%WhJq9aCg_qTvq55#mp^EmajjXnvxqs)_p16%k+>Xp; z>_977+gJH3>n7xtZo-FbU*+SNeU-lS{_i}Rmpjn#ppM}WzT&5v3r=`igSwe<8r;%^ zI<`CiXhz!urFM%)GHim}6aUPRS=r*5n_3IP$+As;d0I?V{uo5%+sjKlEDAVeW6-(tuC`SQyW~k=a(i{%wnoF}9YT}}thaGw$ z&;b#H!@0YRSXzm;IBxl1NnuMLVc6f%yjP=jvcx~1?B30hG3lN_?{b`nQE_y_Q&69Q zM#oVB@FqmesD~;b?gmbif0|2!>mh?lhVM0y^Z-4dDyUkOp3KA=@l-}NqTWxY!uKV9 zD)N(zcLx_lb&J$3cdpQr22X=sB>+o~Cz)6i8jh(a`-LU>(?9&tH}{YYB*R+H_644$RaD&Hw-&TL zoS-R+I!BXAtX+pqp`9~ZPMQ4_JIllO6CS6mptWt%ri%~CUQt|WJxyDRqs2q|jd;b7 zal@S(@MQNl4Hzk!PRX9#bQ|drUt1z!TcuqwcT(|8Hmt9hlagVyE~%^ot%0-?j;`0w zbigR#*-=tGJA(D8AnEwY6>^J6gx~1)()2ZNj8+B(`IDc03d@Ibb|=P@aG(qmb7N`Ys!GEQqGMT|3)kbB1Z@rA$lP6fOOhY3cVdTFQRPFC!g^S~OFx zkr&pWjdthGaS9l%E$IAR9<61&^EbA#h2GNJvd;G;?8$5#Q6z+MUH~cQ-yz@2U>ev(24MJ>Az`!RzR4^th`Qom=$VaRNmS;U*wLL0H7p z_H!$+HcKtCCZ*>vE$7!m)U3v13MZk}7*4en|HAfKt|Z&Ho_LEFEDE5J%>=gi4+uvo zY3LSc2VN*$g*ieqw~NV#?TR-+^icjKfH^roFEPZ=ex&Q%NNee8w(*AM7F(z_yH>7W z=!Md{Rqfmy)2F#SR}ON2Do@TFjw-FAiwpAQuds9|+@i9?QZ3aP6lzDE$~9Sfqh57Y zy%VmB9z#c_xZk3AoFsq7*HpF_Zwr1w!(=^nqk|~uGv!D{Rrt>Yi+rs~ugI;czagq7 zNABmMnJaU6uI$cp<+o~%43m7$7~T>vwsY1T+kn>mbu@?M6#Ov5ZeicUR?GuRcb*P- ztrpU=xt?g;9O9wYLx13jU)l{X!YU8P*hsVoc zC!l@L&(AJBL0yY4&M;N4GtAFU`_QerH@^0a+<}D+dy!aSHN*<@DQE>UxHkn82<}5c z8^L|!a)~3pZM~(HugJTQ?^C>NH)yHWNoe`qlMz$`SI! z>zf;>cdPQaJ)VajROOM93qadfwX6&HJ5b;CNvd^9S)io3V`@oEOqh{bB~!W5cobY07#=)D_w#?FzMoID zJa!b;p!xu8^Z#S+J;39ruKwZC%s1RQ!2T8Ig~g&q7dyl|>&nTS_v*{^BYrLiv&2}+R_PrY&Z%b=i zC(8L+f>YnE88SH>7mr0Za8*j-P0Q@?Y4Bwz;0N~zPCdhCvK-WsR_zwepWTPpzf63{W7MeH# z*pU1(ymYw!Frsv?cpf~u2Iljp?$UPCRJNYMo?-W2mDZb<{Lkx?l8c4YOzQ{DZD|67w&; zl|Wqx%yZ8daM&j#D9ooJDOCDGZyGST-Fnr6A9To2$Lb4uH{+5|(w)gpi|D=+E4l%_ zV4t|r$518-*92?>?vZqO8C>Qu49AvtS3-!RkK1)!;>>h<`A(nAxG)QBuNCA1Zj3bD z1JxS1t8PwAPgtPymJ=fplPBg$RQ70&9dP9mjSUywa0Gq~ULD8U{VC>)#PcrQ)(kR9 zUxl^gQ*7l_ttY`Sr((%-> zuW&m)4P1R3wuLQ??65o5ZP*=zG$k2-B0MQcM^3N!a~e-~Xum##G55nqG$P6u?L`df zxI@k&o-<|^kvBE9U&q-_ceI3st`oW(k{GfbT|)a~lgTQUu<=$XGE5&lM!`U(i{Ttk zNu$zAmuyJ+Zqh-;U)B-|!Eue9N&@LNlGH@RmkuS1iVV*BUbO$l;<(H-Kz zM;j4njd`aVzT(kwH+ijMnXF$>yQHrL&SR0ppg8dJ3GI_Ed8R^~6fh-8%31*#)J>g8 z$xtaH_%uSoCvqM@&IHKp&ICKJ5zMeDWK_6*+ThDM7EaGE;Xg;ox!F5`7mhXa6|DP3 zzF*OOx~?z%w>jj9NUZI)ia$_fAp|L)IOJalZ0GgT(#;$f&{>OW^V)n_MKf9OL0i4Z z=~czy6iEMinCzf1jU6;a>tkm9XuMCAeczS=>CHl7Ur(UVN?%6dFtmY+50~;CVu6{@ zG!eZSPKR48Q!8V3dMODjyWXx#C8x=yyEj#p^n@Gu(%306XtDqVU*R3vD2aJK`#%QK}PY^KwaoJPv2pNRQflodEC zjeb>k>3h@Fw$4dBK+F%cfvr|+i(xKBDt!t!g_TbXM?jN5NA$kf{~OWz@d2O(6sG_>lYvSj z-2xCtj?ccQ3azxa9kI8cs*!1c6!JA8iccrMkfA`28QI5O7TI7+1*rFlLM z`Jw#{>!sozCfWHS#|A@;uZ`$VL9w)3b}=3&;QRA&nT^ddp)Qm1$s*0S8H{q^LxPQf zSw+8HzG@xNK3_vyt`0F5W)3=vA#al@NU=u$k$poA977`#W2A>30n-ul;670a-z+!w$XHeiR#fL zyp*a&!3yaU#kIwG*j!|2t_wkJc~<`nr7N8vy!dyp>prg53m}AKFS%0RSb|KrWm$T3 z%!3)Hczc8=v{7t%i?+DQF`JPF{}ik|gKb8kY>3atyfb3wk^V5Jash*lR?F{8kuB}- znU4nYs*aCV)D?XRGmZJ*iktR8QPYhvP3qIWeX)^F%u6~EL}6YLg($z5EN{C55p%MS zm2&jC8d6{TUv{{*f za~w`5mFQtJRBQBU3+yK1OvP{|VF5XQg=I0@FmI%l_R!~szs$xtN|GJGN-7tV&zfc~ zG^fv()gnO>?Kw$pL{f6A$8nU-+f0`r7Rv#)^lQ%QX_5h2GMSpkF{^xG45La4MwM)B zqg%G6jc%#BxxkpDmSUMR$S1OtDSaG&cLvG|CZLt#UI{1K3eZXhd{2Z26RezL4?2pK z;yU4hNF0Z-i(7O5`?|l%T<|Of4UM0Ob<{Ogp3T2D|=M^d2cd6x}jWJ?< zm#nqMM20U@9OG~oNv0Sc1^%b_JvvRim?N1N!+sI}K)$IUY#n?_nL3c%4?b2lkKHxYnGdyTd$ z*eff%Xa-tVd`>Xt{z$NX9~AkUXlm*fjF!33I>lxUPXw_H$HAPdG)8nH_C_6NR4l@d zb^{mfwk{EUf1P;2ti0t)CdE_$JwZ)Q#if{7zCb*(h%F^v(m{r;x{|@31PeP|A6g&; z@U-MDS(u+mLK;7R@(X=Qu7<0C$v5$%1mT}cTzj8Li#`O1Tw>34R4!3}pVL!*$hA`EeDRA8u`n_g0;`~S=-@BhspGj{G{(-9FH&=h`Wxn<^vW0sPB|(0Ll3(o~^YDh%2RmnmoK#N?bK zKj^9)dAjoRB%Cbgko(tlxxMHJx<2ctgJnccv^fso6bZjbAwlX4!t3>$z%Mjv#m2pk zkpPuu)~-HfOKYJ=n0u=4Y&t)5Fw^3|82MiUb9s{?Kd;Qn~v$_ zB;FB5leHd5=hw&{?S?-)5+o4N3oaVPb&(6gLqv{TkZGpWO1eN4^C4%=+DqxOo@BkU z8~XzXtXIBMr2u3jOAA2OwY1b@w54Prv?ZK6*@ZxUjQGt->saypHr-kGiZS(eMZFa0 zg4hFI9eF&B5A9e3-6=gDmlDf_Qhu{izFA872EGWm_uiQ5@?Ic1zJRXk{xtP;ChWFY z{s1WQ4&j7Yg|4ph=nTuXS9t>{J4cK?Tx{|~GS+fY=3USrI}uBWN_qr_syjo^^0hQ+ zNFdoQSBaFBSK<#Lv&fX^`W&}|7Jg@6n)nF%#19WbH{&zt=UhUNobo*8ktdSTEQ{IF3dmwJY`51A~ndHuiyAM2@Tq}1kl}qIkvekQ`>)ooN)X=eDwx&p=-sKXp z;#y}qm&~QP@&qA8oSeyJIP!2Zm!YqsQ(fZX-4k0P;_mX~=F;JD^v-u;cto0fUXuP; z*3Mk+datow`E=V=I?%_P`g(t6eZ6(1zTOwCuh)_=_4Q_m zd><(N)l<_AddrIpuE%L^Egi5u^2(ifrA7knM9 z<+SGqgvSR()=6vBZ;ko2twcNjh3<J8CW@XtgISz6KS;D=b z$-$YkY&=9|1l4n*ZD~9HR+1gkx>QbNa^rN-q+8wFSAH!kD8|BWl0H=T@pUSE29lPG zTiv%d)g=d=+!ylFsbFPE4Qimm-C4o|I!W_}TFHmYUkOH4h|Zl0yo~%xihB1W#>YWa z`x5T*bx`f{$T6c`K}AxAe^UHe`t`4zO!KzCFMXakq(Bs&la@G&OFDjk1FS1{vTs8d z+s++GB%mRM;@&E6J@Ku40H)|brGGHnE+2#`Kbh#vGpNGYX1K~@9pJH^Vzb`kQu<8{ zoT|s(W}PQ~KccY@D0MA~k_iZl0#jqXP=O!Rsf`9H+wl`#czK$=KS80_PP*ZxnDXd? zG{>r?YFZf;74Y_Id`vQjMu5Bux))xN2C&;2er0vs0nmnjr@o=bGDh{OG|4d8ieAP< zXWayyiSjTYmaK8t>amWMz(C?VbG$WC9Hft#zwjOA5>Pb3MEGqIq;NlF(zie>LSRU0 zkmWtRU6`4Uz&l9x8fCp|QlbL__^>Wo*`;jO$-P zw3!(0=Di5z9UTVRXL?Q#qN~9P2%lp@F2Dv7zenQM z=R(~1qeSP2bLT1SgRwwvAs$MSMv`Q;<9Hyv-;M5zCXa&b{tRv6{bnq?=f2*Siialo zCTm&CZjOC0BiijJI45=mfCND_mlMk6_~B)QZZTcv6XhB-rBj#jNtMwJS%sF91U!6^ znRl0)^Kh`32T29i4yj1^E=c%KMW3osoG+pBDYZ?>scl@rn5Pe1{GTyQNo$xAy+nHC z1dTNRP!KehRKW3yp4imeWuz)@TxSRAlm1K8S$bI@)mb+-n8>=ZokVMb>?Ay*JW^~Y z;oH$Sas3(mGr&FY-TqDZ8SCqve38D`a^XPvv9I3}I@VqN=Q@Kuf72nrWfc)jNZg{@Bza5e}e=f$H zs2(nQzH^VZ^3iVVYpi^l+5QZVIgUo^h{0@=yxoIuH_0pe++975ZuSZBEEcyMd{r?Z zm!78Y{Veek2@g}G9Anz0t7a)iubFTobAIohB{{!hV}r=43&;q zcM%t^Vw71P(>U&AmOHsM zjVT+CDNEh$TfcVtL^7CXJf@V)B+7|rm*f$-OkqAQ@LYQNg2`un9qN50loQ4gxrp9} z$0Ln6E=<<9<=P}!-$LrOlVgqYB08uFXgg=3h91DtyJSi5Tm$>^E>x12Ah{{bH$ zpKWnW9;Cw|+}MgAOvm^WG5lIRDIt+(V4`&hj9J>Di47N^VRqVH+(t&V3XDH z4^oSk3D899E@Ef%TXZ)*AB}n>d*PA)CVN4$6C{se;eUzv7Nr6uC4BGCG6GjGV`}Y8=1H`X4TyvFt}JUxBR8Q<-Pn`9T{+Vz#bjzsei~ykxlXuiMhUDEPIzaUJ;*^aZ(3BwDnN`L+kqe6kyclxwzB+1QTc|t_Esz=P*y?n zey;9ava5CIn{N!yn@QI@eaVOvn=*EA`6+9e=iM_#^0<)M;Ic8KO0U zs{$#tB+tZBYDrc2K$#yvpCVc+;~>`gWjI^alBQbtX320ZNkKQqwFG7@wJsXOUH)S! z7w0{iw#H9Ydvu;P{uHHq!F(^@A->m!lJAvF5Z^0h@V!`PAaEcLl*X5%nEj*uhW!|e zxD%1n<%iSCdi6)xNG6BOw=3s1^1*Bi8h1&m->zUO=z7qVKd3IQR#ERN?;-UX?`JU6 zTSfWOXR{FQ0z!dO&bAg(@L~#2OOlgThk0a-elxVzyg1m;rX0h579IINWIv1Ud>#AQ z*}QEeA+nHm@qP_y%n1Z8xQWCCofx}zW1b4-YhJp1i(U)U*6te`&+M>v6u)UYCrGWa zwQDexQ^t2gTgxd;983CZF24rR!_#TyZ0&a+kQxAT?G#rd%w#(4~LTM1Xq zIBZW(Sbz9Dekg-eUL!+CgsO=4O%rFyO+;fehTMYd$PQJ9n<#%j-B?R>ohkcB(SB|l zvLE|o8*4})cJ2Q0nMx7P(LQ7y3!BsdbEN$Z+v61J_~nMIT! zu@g{YR@#9}4aZJEO&b>IS$3iyQ&}9x06c2|aGwV5nO;`vv`&=&&oSc}t{&!uzY|4> zso>Oz?jWy?-h#!IPv72dQSk(o&1Vbx3r>r)5jN&(~Z;jbO-9>HIiRe7Fd%f5R@jf#79UkBN z`Wtt|cA^*4k|Ab7h|)8&O+_A~BE@YekE-QY^-S8?st6cdpnkkJ+vHyi*Zhm4YWWw1 z!K0fqG-9TMWK+cK076(YoSN*ao}?|aiTyYDo>muv0&Mvu1%MStus}u&4e7)4&C_E< z%4By0)x|N(6vFtVQ6^E(QgouN@w~_oGSBf@PY03A`g@32<%AP_7414e zrj=<@XrX=aSTk2za+W@;g5SvG7V`n$(plI8lhC zW-Fii3N@#5>3nHQlbX{7))t8+fHM6nR0@uI>4+wkW(sx%0HqS7HbdrY?en#rKM(^OwfHxfYtaUx{3JK$-zE|?j#l7^BO+@U# zB?M96N96Y)-I(`4n&O3li-=4R*Uq~j6fTr}HgK*PkLsC}wgfP+M%2U43Q8*VS_Y-z z+y6a?%JVhd8nd7B^Hsqx648mEc!7$qOfwHXL;T@x^v|u9%qc9L(YU;xSY3>g?5pa( zHLNgYRVt_9o0<%G%fQvUtsZe3^`QO1zt)m(P8~g$>Z%@~0aQB3^Bl!)D+203#_^H{ z1n8DMb!M9vODvLGIVWjhWj&;>I1@Ahn*Fl>Q&roS>OP--N*n2OnZQz|a zS9Fq?1JbR}lWu*hRMb>{s$udk6*x)10z81yJ=<&TY*IJ$*&I($%H+Gi>D{PnxR(Cc zZoHs=;{~iHI&d*D`tg@c{7ZZ8Skp!($!#covN;Z!%EV5?R<#r-OOH;k$-OtzY1Cmc zd>UTHEVN5))2CrC^EWn?{EZIgZ*&>_jW#-GW9Xb+YJUx%h944Sl*QK58l-G2mPS!ut(x>3ZED++!^M{y>T9<-i zh5i|@kZ<}|tMmPMnce97Q48DZeLt?{H1++6I{v%9A5r61^!>=2^si~@$M`aJuVPN? z-@B{dw%N91DLq^*4SLs_qnOv#Z;AB5kJRODM@xLtDN7SCWNo5pD?S|0ceHfa9ZvWK zFrMgSaNj>qlXg%v0LH!R`9YHWK^XEwXtIo>I;yZURHpl#v;_rLc?zmol~#uPoNe-- z3|mF!cdsMrXtTnlAg;ylslK!eP;&j_KgIyipOpFx1)a5NwBro5%H<2l2t4fvdGa9^ zDBX~5%NF-y=qOw8@-YCVWYV0b=ZqblM)H|HIKUUX;&i&aIuhX-XznDN+#Yz{(be56z$N-#F4<7MevwPzOrQO4go4(NJs_@` zE%T-C0+^C>KhmxsffXU`%H^>*sc6l%30x0cp?R!`kX&PTH+#Uj=gI~o7%FqP4wv#aOSiOvjn0?xpd-0`c>MLW!hV(dhsE6ipz z44-0GuB6MojnkH>_jV#D&n8t;R6!A~i*f!O=ii+~NK3BYIF*Vj^qH!GEhw6n4wIY_d@X?~myT`z{Y<1+nUCcy!m;tiSm^Ie!yur%M3wQM_jZ ziu*f>a2V7<=89rKC5H^9Z4*@n5avIv{FHj{vx=bMrNtc9{sINzlPW`p8S=5D8!Br2{%G2 zGkQJa*{p%@1X+CYFL_iR{WY@{l;0?&2xIEN$mg{)@?K9_M`8^D=jTd&-ARB@_Q1ph z&?hLxcwPl*tPz7Jn-dJXNvSo%N-OlyCA)}}?R%@dojaTA!mMXSVyA3~Id(g&M6_1s z|AHa_i~oHo@ef$yA8;R%xn!-xKWRw(efefc{DT^af2~4Gjl{oIlx}U5_@{CymiYU* zRGq}%Zzl0?9a`d_wsUEg_@|XV$Z%`C_FI32HTzAz+n}Sgzt~9|IdwWpPIYdbt%{c@ ze~|u4>PZf5o=z_z)s%dgDaC3!erI5+DgD42N=+%*2iF(5B&#Wj$r3{*1)j|a%TRAp zMXA+PQEH9Vd0JUTDG(2)ic+hgq7=wXqMUe^DoS#@E#>7*@^Z=zm#AKA$NEX*GD<%Q zsq~5Ulf;Ue15b6Pb6#gA-Njw&uD?ZH8`AT4oaE z#Iw{*$`tG=4z}; zD!nAz9^P%Y&mg@d)-~Gr|3TMC>8=2$IY8gVh@)CQ2W0&X=KX#vUdnffl^eL39xun^ zjr4dF9BdOQh_*VE&o=<^^y$l)Jur@Ht1<^E5 zD{TC}QTXRXsW!>5&5$p#Br$Apj!|4J8OqBO@J1uREh_zt$QzgA$Uc%L1Pt{-GE8o|kZwuj+4D-C%r$oOfGqN>7y6E1Rr51Yta=mbq7)Qjo zV1ho4@Tgk}nf zm*k9j3XmWX!Y_ZZU%iLZbl)-F&D40WZmdc58)KZV+b=)JId7qy7aMJ2ZbpXFss1e! zz3m6IJH!o;(?D&4d$T#}Do@GQt)K0MMewtfZ4*rr?Q^LM4HMQGfIq$`(OxG^aA$6% zTBezFlVjng*+S$Gw}p?8+DwYJ0?o6f&f}0~cgiPkfTd5xt|?tVS8N@EVFC%c#8+h} z^KwO(`ifuVQvbFB9H3Cs+EXhnYljtGCbDXOnc5Z9j z{a2Hg5osa->+UzO?j*b8!qj?P3ws8nsv@gJ%Jv0*hG&hJKjKC2wV1klxXiXO+S;at z+gj7a@S8WFEB&3URQgdFxXo7b|Fm_81wJcyk&l3aT?zhLD*TQwaphIressBbDcvQe zJh~!IW?c^D0qZ64H60Kb5hK461s>Q1{9lT`eHC~UOS~fc^|Y*X+SZ9MSgx zIH`0HtpE<4q|!+$9hjx-f+10lu4R@^fl!X<`#xI`Qw`z=Rj7bSuQlVP@M(^&W5GJr z;zidh!8+B#!%(90*P4mWi!#pCWNYm`)LpXBTKiJ4v-dsl6Y3bZ+RNP=UVJuDewHkMTYY)##@IxmNqP2NJ-e>_NL60zo;IoERZsiE zfS%I!vW~}O9cwkz;Y%M(Y%lkiS=S3(*Ri$~cST?#IL!KB4na}P)ed#MmqJ53G5@7@ ztiCl}e$bforB7E3F?`y8U zqq2#t7w&@$dt#p3U{AcacxrdEF8PeeDwSG3*sPHivb+Dj7&B{juqjs}n(7gn`U45y z81I>At-ULs3;2*)N8Wn^SNs9viYe_;$R;9i?_Mw0};cB4KcN$klxeC6Ghym7YnZj|!;F4jI{(I`Tb z!<&tivpZ7V{SRtp$yRY5cu_k5T-Byy&+e!9Z1@8pB5^#9`j#fZH*`m_o;J2_<7}rpw3AOX;)B+6qD=9rkgdfU% za-aD-Ay%IwzBFgBg0I>K+#_w>F zWDnsZiT!KE^-Ptpy~MPX9!7MiS_?6sclpwP?HpYe^CsEOj}B98=WH`Z^p7Qv_D42p zC1P$V$lu*KSP$6RF0QqUe6=B4@hQ9Vpr*Z^+*Ol6cIC%Re-P3?@F30dgItFw^N=p{ zmm$kML}ec0GW&7q=tf$@hty+H=>*YODGLv5)NU~~_K;59-$TKgdkw&wt>gKZe^-;dF#tmo9hBRbJ$mDheLHq(W_n5 z_wiJbuxH)8kyxj7W~X%jEMZh#0NbpPx0jkxObdJ zZ>{_Wasay0h#k@ba)1eeWb`B7AOilV@TcL{ry}#-)E0RcoPN+PI=us>qzsY>z`6A0oph@H8hdkB9_K$w@TByv*FVSP5 zzQ_&V@&%h84_6NgH?pjCtof%{oniyDKtCQx*nUJSYt2NZ9uG!W%J!qjeT|1TRgc&H zWyh=^<1fHl_m}5nt9m?|#;s#3=sl+J=-6k?NXuzaF!~8hTkICT`XuJ=3Q#$eKIPoVsaUV}7KH4ntv1W-+G$!)g94T;vXM8C~ z7SBJ&m+&HjoZZ!*&_&Q)eVBgtDqkSdm*V9Vd|5SY3{Ii7`g#3Dvw8hxvw8hRvw8hx zvw8hhvw3~C*}M)mo7d->&FioICiD6mzsbBl?>CuO-TLb0^;>dYAC>d^h@96;F|T+z zNpQjOp=moTTg}mpEB(B_*xIG0Obwh>??QfBML5_EHfYN)q zlE~F_fYS+d1A0UrT`;LEn|P)JFFaekXKX}FM8jUV3@F0mxR;Y$y-&5-!oJ1VfFqZ*3b!eL>Hc*F3{hQ@QrgJ?AV3zoix$myuYslemR+L zmuobBIaa@yyEIa158)%?BCbRtmo#j1N*K8$`lj7FS^ORZcnW}bGyyzDe4SHtB|O`( z>rUNHJGE^ayS8oHHm9B1Pwh@^+qUgp+uZd(@7aI!WhF<+N>1*qtgPI*F2pt=)Nb+- zrF0^()&2|qcXEH6CRx-LYOt-d{~qX^)f1{n5;3qKx{_%r7j@;ya_Oi$^e&=m-4o&( zrypLTn7rEvie&ph#QrXYDFDPc!(saz_e#a}`lV~m0;QqwVyR-qJ^C`qDa=5zojhD` z$5rn{nY{h3dE1_2g!qnRLwukd(9^Za_Og@ z;f0Z42=4nodKN7f-*Mjv(yT%D=hNogWrW}fw~CoOb>U_6Gz9ctVOX0ozb2o@a&_4S zv^~q;C`nkuz1)=vr`$TZ~^@%=E$kxDUJqKW&zFPkFcU8jL``S+E+lk+xm0TXh$LySx z)+c{h8hTFG1fVLWU7ti_UcP2threIE3^F{u?BSaZ_S>=@de|GHTEm|2)YBmNrmGg^JzaOr5@Lk96+2B2 zI)gu^Sb-Q2I;B+!O2LMs9^rCf8G(qp+cu1G{4nuT#yYrY$2OdBDb`{{Ps@_f;Be-2 zR>mNA{BtXI_s&&vmhtWNXB@#B*Xa~WGKf0j6GUoobQM-<_oA?IgQ!s;Ftph>>*R<8 zAedYp*G7v9zcHP;h0dKo?>234(A4CdU;cGffS|*2#dHlISH2`KLh$**k)QoG?h&39 zv|o6bovVIE)Z`?<60D^7g7Q^fx^vYJ?>$j+|HwWEweO>N7df^I?W5^!7eeKz1(rG) z=A4p+CB5KW-4>eB@S~Rk3fmFnCa=qH&}lm)^pe{l1s8KnuKPspjqc>KUozghW>32$ z@!s1E-@QMek(?s+`yrhlQb@^u>Xk!r&s@68Q(-b7}tfDD&W@Z_@rApvh$3zq71@&U2KDdnbn= zg9f_UjSXo^GzkxA?=pza`)qqJ`d9Wa&ia}&$F?0q*U;9@lz#@J#o7a2P~~K1dS4m| z=AO6{Om3S0&-X{~&AFSZz#GQz#S;$cpZc=ziH`IYG6n`<+kaN?3C8tm3-^y)U;^+S z?%E6tE@D2F>_9>xcss>cN~2C12LNgSF7(FQMxToHSk5*_a<$kh2TOvkRe9y%2wmV#`(`J z1@YRfhsOTqdh_!Y(>(_pep1>`uUv>>>q!#8lm;Ite{^6R;hEB`Ft={X#A6rYRF)VH zc57NOyj@Muwft2KWTWehzM+FN^JlC$w+H4Sg&{x&_RXCCm-(Q0)>TXTT8ROU^i|Qd zn9xaWWns1puAzzcLA5!O^9u1=z*x-rtyc^9=67^|t`%_C+vZST9x8BSfqn>-U&&f#22n#Va%7GMC7dz7$cKSiiSnwxLLc-K7g z8I{to1J2i37W5BzjQM>>8XfszM_d=Y95`}cbpqw}FIIi5Zt*~R>$F0cpLMc5~pL)liz9Z>+#%eys%UcFVRl618*^;J-hOk1X{AcN#{<(-t7lhdTbOPolgvM11E>(y zDIp9?U!ZzNAD$TFPY7~rTkWU0d=>XnZqE4DsC4H;n@V>$!akohMSff|M~+btG*v%S zXvJ!bd;2IGBREGL`d0+>DBgx0Qb7i$`tn;7giXtUr19h@-z(bmg(*jzJO+&^xCCf7 z^OkKihmE#Y&YeM%`nN@Fo_bdG->U5#YpK#NXQH{CC|<#-mGbX@H<}!pb28tB9BbMx zCH0<}^f(RTd!645y#>AsPIkz8v?7ncm<;WE=&TBR`>2tZb%mSF@JFs(ku!@rUo^Bz zT+F@`f43z93U#M5e0|t~botKXubm)=29_$gBjbXO;-Y_&lG1og9%PP{hWL72X-D>Gh2 zt8jK#$@;?55J2m^Zf9bdB4bDchj3SDF094KoV%HtZbiXDh3rb=QA-vNI4fm=`T1L$ zr-sU!{K!iitvN9d^FzNP?HMhP6qL-d8hBy!_2t|Db&372tLe+CafQfsmuX z*&x+iGjEf=^DTb*Usgdq)~ySC5B0kGEV<-6EWKy+TUyP)eQ;#UBf=ef*H(yxB+L)z zp2RW}is$n-e!)UD<%zUT`rqiKqlq=OmXXc%n2`eN;uN;6Vb+gC>YMXrLfRyuNxO78 zNuO43`HhcJqmMERP4JrxaTd6fSzMXMdr8exak&a*bHk5XI<7?J9aT<`l~*>==#w;@ zVJN{=&|cdAQt~hy;<5eIvu0^K-LukD?%1H^Q5}Ndu4;7Rno>%`&mUfg3V!-V`>c{mgC{ z1;Cv2d!7!+a#s!g<6=?|6&o^T6TXY0w!!rT=l;NtESw7wXQ3B(jHP!vtJmW7BN~n? zYACA*rB6vZ`KttX7-^QF>{%S%{UnIwgjif~T_X5s-cS23UM?^qvWPCMSJ zTdrgx-xqJ=*@`>yajV;C7|#vKr^i%Q`cF6Ux(QPfEUr#PUbgNEowXW~J#(;$zh`Eg z9A5oPbv`UE?NZk{Ycj7s7`~AvwU6Xj1kv z(8$mvO#yHW6$YbhQIw$QA>Mo^py;`sT!8v=?1s8b+8qx7SF0W8CzIXh3E5>3KG(I^RFW^hr9SC>F5+fkNb&YNdz@-BO;+y<)vjxtiHO%PKiZtif15sQC9{{R zK*$UcWme_zNBV$ocDVg#IT<=_;iwqwY^Czxu?rH?BQCyRl2mV@Q4Z0Y4dBN;e<>AAd7U z#lIDR3Wp!JKa|!`BVqTUN5(#daEvAgf4x`908X1}M1#1XA`7V_A|DsB=yU%N))7DeR$yKJSEv-S)ap+p)IV;@zDf9dPH@L&nn#X0GH&v+wB*{%QamXrN9CI#w$Qf}|*;{dTY0g}Uz0WR4)> zXA=;cvj@w&L`PC1pF8{)5Weu}oGD zkocrM_?Vh8h?W1^TVa{iU7-BFP2DSPYMSml9ok0rJ}4)LEcpw5+uYGY7KGluvbOGV zLOC!92DjaQs6%$q;d&75X9?ZOgvA`h@5J0QOn3?FgpBWv&n?AsI5Qf-sYtfTJn-lU z1MfyxS(@+>{JD}6x1k7j2wfCVJ2wIbr|$h<$k&Ek)Ys?d(2xun0ntjsR~I^hes%&E8<`5XQCSCrP@#^ux|$RDsM zS(mX~!l!R&MA%iX2bY#&@pzc#?_K(5rDwk?SK2A{BI@_mcjiS3GWdc3+@SxJbuswV zSM9Kdbm}UG7oe}4dl<@j5oTz*co>bPyT;5_8>TZuPs3XuEr^^AYD=9^W8+c}4|0cd zgO6;TsUJj;ynPa%3$xF&*#ax2#30}XebSI zSy&pz^v;ECK5y`DYxVn0=zWgc*S6ZcSA1p{3{*1J{VS8mK8 zw3sXUS%l426}~lxp1{+B^A8k~I~cWJhaJnW8DYP7kiH?VqQvpWBz~3i=w1zGc;~6Z z7g$a5H#U8P#2yAGb;v1@oHPH|uo+lM67Lc_M?OHmy;G0lty z9&DTmzhw%RF6hMaH5f9wE~LZ_huI0=I-EwJ1@1_-FKd#=tZ;$_V`li{`O7cR#ZJ=) z1ZHb&eFK@I)wFRoB-f0bP&rQ?@hDt&-?`nX+{B5kTxz-*i{RFSls}#NQk9!LZt#$^ zBmEv;O2e%PI@?%z49S=cb9HV3eZoAQX|IVd=~1m z69zr`UC7wpoPYPSWZ3y_o&R{jr_Nwf{E?hY4!HLcp`R8a4+VeBGlly6ORU3{!0&sB zUUlZZ%VzRCF$_iv#r)quR3uXPh!J@+VGGnNth9&t1#DRLlB@x{L06vQwhOd^IMQ)p zUuprGtAgIy$vg_fTOad2-Ji(}`VQ_%n{OorI>Ugl!n zuU#Qn_9U9efB;4Iz9I~*)<%nbF%g_wk(f7zG>tRKJop0SU79G;LqCqqDp*Oh6ywPQW29e zE!?)t-+-pKETR$oC#!@z39W(O{xGkDL?5DvVPf^~tn*}d5NYaU7oeS$u~ZzE&0lE{ zm0g3z9d#wQqJYIJd@Rh!hi%`ueZIpg$S-vAhooBC8BVr9ou!>}W70pN*V{CSmvOwW@aX?YJpEhG)N|fn0-+vkIPzuLDGKOEGHf}wRvGtLSu%>$i*yJOw4%#Q zB#kZVKL5?DB1@TZQ=wrKg0z;REEati;UTpOL#UNVZ>FCbfZR&Q%~itBp75cF?4BZ9 zrnJ|S_W%)9FMhG14nUwj`iB?L~$cATtAq%tjZ~EoIOWp|cQFE5VH?o%% z{OF|4do(2@rs=uzZ`!bQvsxvrmVP{BEI=Y@q`rs49tG?6tc=NA1PCHnq8+_*EYR)D--l_^1StE6K7 z@4W|*N^tlXoTfS+xIQ>`n)IucY2v=p1M7Hn33259uDjMArO&JsmsjFI?MD%3v6Dd-$Hoj>ot=*-0x8)xp$xwL&6+TuP^B zJ0bzmnqkcZ=bkO@ekW~AI;?xbI1YZ-Bui1mP#1iY8iB%T&ObFt|o0Xs5>`@}o zIv5j^-EoBs+AER81qb^}&S61nZy6UM&l75xvHxvBSw1_hTj)+!d|-2DWMrxvGn5CR zKNUieR|!2(W@^7@aOR_!LAC4}+5UAU?7^v+s+JeNO;AY0vZu^d zC18lNGxs6RS;knP8^6H3Sq5@ks|yEXr8o?SEjS*U6@sgtlznN=No2tyep`U8JSBcP zMi)8KUC8Q~c75a!?+w3^(|ktYM5=;1(Lcp|74u&LZ{OiNKNypFl*br*!$q$R~5sJC0$BMuAlP` zMz$g9{E__(oL0!oC&*P}>CPtI<+P&}kKD7ZC3S<}ZbZ3im7eRWS*nM`xH5dv$BD^) z{uC#P=Ti*zDJPR#^Buo)MjnSXHYa`L>XM7`IfLm!H55NF^3)}E?G@; z!xCQQt^K!xaLHi#6!FvNnF*6y$NsPSAadDI?LdW_qFc2{2ao^Z3@)djdal`k6vQg{ zxoyhIZmb%pV#bV8NiXr)hUqBl#>m9amf&bJ#R$+|B5G{YYnDa4L7q8_42vsEWPIP1 zxF@3d)xuQ=y19|vEZR4*NZyW*a=4~f6v+3>hk1{h`@uwO5i>lbc8GRWv+Zo|=vKA= zrOBC$|H$^xWzKvf9!4&>f^d11k}$;6ovOc)JLD5!oeD3tIEH&i_3QVg6l*iePXt~r zY>8Hd@^~DDq3otR>t9++3Wha8#Kjo!UMpP{vY${DMlvL1Mn;NR(X=J;#0$tj6Gi0X zAb~kJ{jr(%2@l+4q}z? zSO(Sk2SUL<5xk#Ha^{DW@*V}AE?0MjvA~2RAB@aPIxSfCPQ>o5k;vwJ9!XDNnyGO* z_GG~-T*ys@Fm73@70DLtaD07X;C|f#tRQW<^z%7-$+Fk`>atuw1F<>3O>6Tv7aDiQqtAV_mvJ-aP4UY=Uhxt{2#syRULJ)AG1QiF{Z z*3(papq|Ep)~lP-o-i)r*Ogf0!KEL-FJ~`3$o)Q=Nn#wo*)5umADjj1t?$)P)Tn_8NF#g;6 zKm0Yh1@J6Z0%qoJ%om`}&KX;Job&kYk?)@@JI1s09LO^l&GXNDSguS-*9Ec>7(WZ> zkMHa7u^k`=EX@WqckJlxCr@^jKBP-=TNX$=;eIxp*M0-xKA?%O0);iUkC*1A-@`V9 z!7DyGK*4>D3oh&zVab79bHez0^OECR6Ku2N8|uneB<*KI+*z|bF>ai>f8O~&J*)Dk z6wAB2cop3UZSo$lF31C^l4denOM^IpF4HKM~nK;~VIq}J_y5pd@VIT#V& zPj1fBoPRznOT-8A7nCJzt^Y0&fx@2&XX*cu^1$RgBN!sFp7i*8FNEO$)h9IuFdPtx zT>GS^*KzB_{G>shOD>HxfwIBOaQo@kq}j*l7rkXblDY3}M0sa_6SQoR40!Na>FCr^ zwM@v)vv+s=qc93+YG^3@g^zS?1zk$Hfwf$Me{X}?leKJc@|oX7BsB6R9P4-&WRg9f zQQWTNr3fNqv=EsXK)IEA-?cpz4YR%t?DIoG*M7GRkf#tjIU5Nbt=p zO_#%|jhxt*lG$cOAfplhzD%*9%ES*IAy4qL2ln;A#bfWui_@>&D^XkdRKi z*|!lwq?PkBMrDV*isVc`cF*H`eAB&&-AhY9IjyZZTo}5V6-W%10B8=>D)4kLe9WA)Q%X^ z=3ISN;{cDGe+Pn_cj&IqV1q@i!6EZqAbdv+B0FlLY_im7`Y0iq(9|?7Gxn_ z0I}BBRu6~Ydi3N|6lemQnw^}u2wHu^u($3WGxI5BOm9DLnt^A_CpSrV`lwO@Bc5Hz zQ(|-q)?pw*28dYCN-DmZQ~$8}*7^3F(0}khqxRtcj)36oWbPFC^0sHV%JGtfThgg} zDS6O%!Zn2yRs$cnD^6jS1oZ;!NVCY&g66V#_`@v8yTfqUV68Oh7D~vcyoqrf#Uu9< z>v72>Gb>G==DsN{{@E=dGMgj{n;QEVn=HNYu=1rA2d4Y7PMBCACBibixcL&~CE2iP zIgUAe)e6zmx@~b)4K?j?Af>oJ-2};3YQi>cuQX&$2K-g>*TlW}?O`uf&-M-!RzM{j zBfiQh^-6y6xJ62SW`Y*`iGHOHHDx1KhGX;Vf*N3336TGo&$vDJ`;>G$nD0m2h(60S zz89I5SbIuvu=1!GBmUEXUxq?OM2wQF$ehNg3F1CJE=smii_nvOh`U#RjRA20tOxu2 z0?*^Za>R6t;)Wvk)kR-Q1(GRy;;)dH!$z?~pU4!3KyD-j#{G=v$J&r;^ zV|2Mk|_%tN1pu2V}98I6Oe<8Knk#*m7qLJCtL0HtJxewZJIwevy zC70W^H*|09aqrd2z0o(V%VXlfTyF#^OntR>af1Vur@#Pm_ zev}37T}*j%wapr@D?@63*k%6s7p1NT!gptb>A{tdE4Y!~688H1eE$APek036+XqoW zb?}D5t23l7DC8OV-+u$Ndp*Kl@DU~C--lZPdZ+DB+MB5XAA;*>Cg^sn5-A*t2WA{&4#p$tkqDlP^xcvo+4)nLsLR9(L z{wvLAq}si}(6Jb(XBp~*Q&2_Lc^Y^{1#9*3etGx0EmKl{pNnL3aUb?VIrp3>+^Gld zE$-!7_=;?E6!X$E$AdhecoawC!~Q z&Q@RQe$I=P2*t3qK5teORmHgzy1p~PTI)$P{|iUf;836?Jo=s-Pe`N_UZx;t=4^-0 z*Ou4UR^}_@=O3_$m%>1Yu612a1GtI&Y_pD2w|Tc<>2}q~8^WA0qIo41PO%U5-bdX; zmQ33F*o)1?pCe2da2c2rh{eX#+|c8bk!JtxXu;tHV@(6vJZZK`W$Fmfel6MzDZVF< zOD9vo{~3t*y)DdR9N5#T}uCU}6&>Yu_@j|W_8A~pzK*aihWZ-D|h zKaGUZE+mW4`G@rLTw-K*%G(cL<4`1<5`inH&iSTnPn~OciY3KFf;lJU?EOZcUyB_t zR124rdyhe=6FCt^Z93g)ahcRo4f;0HoLw#>0i6x#4>W1YeJ?ck0=x_q&hkF-sYMv} z<2RNo-I^CWbnZ8$E8Tf&F99yw?`Q5eknT5@OWk>-K=~@rW8P#5NGFLyIspI<{qKoJ!K*^|yc7jHq&{=63t*YRKI( z<82leVSzW~t~9CFglK~Bjl|HD-&-fur#NsDs2DF7ciwGQPd&kauY)B?J8h3?VGWi&ex4;$E7`@Em!uzcZUUI1LBJ=Ku6*_) zH&jgHQ8L{}+l{+1jfcpMcB6x=2c)z4cQ8QGU+QCL0M(nNY;_mz6Ti0REXC8)mX?9N z00kTZ4A+xfpWAlH&v?_ev0W7VYs!UO7gR}AXFAz;LPrMtzXUf{-Euf75+8j!|dvbbd$80n@d&^eJ3P?M2<^Yg3 zo#(ERkoZ@U%^0o{vRsk>b?X~5HQ=98=iIZbh_;x2B7QC%Uv%5LKOt^UhOK**w``J~ zmyR-zp8Tmn#f+ETgCKTjdZd4A#e6~WcnRq|R}93;8(23{P9s!#H(n!s+MC-z!8=7! zawGI>Hnx(ts12|R_?-KA`}_JN`fxOdTvDW+z&x_JN0r3@|PQ#?lf_sG`bb^iX@H=^utEpZZn(lH} zVPM~)9D#QB8NKvTFEVPb*E-b|UIDo8Jf*XqnwjrsR1RK8?#mJn}SG8!L z=ahA2F4M-F;Tkdz_8(y1kbC^|gahLiI2;?+{y@6N^}yF#GN2C|e{>7yEBYN8Vp$c}G_Y42Q zqhQ7tLxY^>ap<#@klkLZbB65P*w=F#`N`)TU1EhQ26wB9)7Z@)0tJ2NqB-ue-h{rl zPs{DS*!8h(&vF{%^ipzc{%D?M>h-YgqQak6i%eKKJ8j=o{JKRi+;~^|9;;Z_Lk*~k z3{L7lB%WF`rU)JA19K5dwBUjAc+_YfEKU%VQe37Mi-L#9D!GBc!Yiw8-O#$B;dsg= zy%1O|YqeRD{r5jmmf*R0q_-eP6=MdL?|5zI!EQ_-H4}(CS)pBOvCG79ZoZ|!{@DDK{V$*}APp?o{qgtt-z8nzDaHpcg z&y55=E)tlfE>;Cg7-iSoC9+6AshM|YVU}&jPHC;Zo&Fl|+b_@bWD?7`Sb@yvOt*~8 z0JwPY6w8Qg17U=~C&zbl{Oz?$I0Skv43(Nad4w@=CuuW%^|5W}EeRMhkQVx1Qs0!i;^QES$Ac zt|-bEoo{V_Uy6Ao(*EI??0aCGQ650Roq-j+nXkd}W!`*pjBjetJ9xmS8GGXrbEC&o z+luQi_V*P2dab>|;B9--qrf*(9eaCF@Z~PRGrc%iq0t}q&M`_hdju?J>fJYcLOuNL zT0)U@Q0wk39l#bxKkNfDk8Up`sdyasDf#^$2tyNQLO|k`cJ7D2(P1J$*^L7RD?sz( zNKwb}a`Nr7lIh~5k=}GS;N$$eo@lNb6pR00Rr*owaVN!#*?TlpA1B+OQO@;^KdI1u zi9ak#XBguC6(;Iapknn1pVqq$z&YD{fv_%d1zmT84_EuQK$ zm#Lh^o06%`*rJ(S^AlIx_{WZ&+~z1yGX4J=z&8X8|37Eo8v!C5r`s%CjHo?KV<%+* zmeO(W*>P0uKVwZc}n%i8KojSsFKry{XCaCgNg-48u8++{|Qs@Ue5xMJC3*_UKy+XA!06% z;ao)30t=p|D$aQ8@4EY1ZR zwj(R_+|^6jP5>vPh^n48GwS6Chq??iDV7?=Qkfyau;HrV#s1E3eNK9)rLS=2Kc;qM z4vGoN3wm=NO(eBif%R zXW!?j7N|Z?ZBa(_3~8zr6PsN!8)S20u4x=xNKv@4Et=A*@zCj%CK& zABTD02GQyKGB?>nu@ATKvaJ~KrQ6x0Q}}3HsKl=if3)Az{kLs1pCs_F>0x!RjI}`?Rl^U*>~ zt0LJ}8oTnJ{art`|5TG^s;L;=fbl|Ss;(-zk!16oG|U{R;lz`#mDfuaIDhz+c;Pv4 z6N&#S_UI*qRvg2QM1^h=++Y$`K-DByXQ>k3+?xIb6s7b^MDHB#h(I-a90p{(eUq1= z;g_YL>(oikRo-TLjKT5b83w=yU7G}Ff$$6%RHWHvs$wk7 zJsHv9qPm|z_BvIm3bSK*4+VxodN7uLCafd9LbUtsLj}gD&~H2~0in)?ptlLsLN>Hibisj?kAHT;cP^T58SheYeN};gczE;%Qmdv{ptY2vNgDj$< zq&>{PfLZ&q9pwE7+eP3t8uBnUlM_ZM?eg4rv*hTs)f4x(Nla7e8kx}D5AcMPZnlk} z^SMdfutFDlHZ_N!`!eE6HDO1``qpZ088v0%)vr|TQ92HHv!lzFO!xeOo#%b4d4xw{ z{s~^na83fp*TIx3xM4s!?v+Rg@YuVC*; z)i=!Ut~dRKjGKM-rc8~7fVpT&qeNV5u&vlC=H?MmgbUU`q9>ApRKnWfB zMI?VAp!D<-4``vtAH;@LQ1@S)Ld^KlsSNsAg*zLj|7|28X z0&8||Qa#~VEU(|u^bHBzP}=Z~3UCX3VVT<4M!vD4YIwu!fEplbsq{s375?n3*1waT zc-eREAlQ!Zb}6Jo1rPU|0-Jn;JWg(C+L)KWQrh;RsIxJJ2}*pxJ?l)lu}w|%LQ(*s zH?hq+Ftav!=St`f4sCs*@fxIGYiOi27N-1mBe#~UH9`6Y8(W4Aj0P7?!h<7#C$diK zk`%;gZg=`EtmDf4I6mg?%qdMmFHP`wrat2V^sYG|#$;r4urf^7TDS@U1ruDM2V!=B ziK%BZmMokbBZ73XjzOml!hSl@2-AkkR03~QGWbx+Ge9wc9iC-Pcxc-u#&YUhn9xZ+ z(e{HB|H%#{Tc>nM8`k)}x2C_+go0f~V77=YDQ8=pG2rUy|FO5tA^4~WwtC%{Wdqbm z2zrp9nFM`yWtfbnK=rgGEY5CXs$@mmTkG1RZwCd&v7Sam^W2fa##=m5>c^TcMcnWL z_UhehbhE`biDz|VdO=Y422}sD=9~77^3hn=PYH$@ii`-mt7W!rdm`EFii|n6*OgII zXQ8pL<7#5{t%vfAAV%_{?0P?Kv${r-fg{Vl?O{I@x|>7v+p|%F(~fwurr_rJgfG*~ z*-L+sXe#&o*vYR~*4}U-(0Ftpj{OfVKDFLd-Tww!XGZAe26o~b?xgZN$6kZ*GsC6u zy4&m(rH+0xx}7eK?@l-c@0`yM>xz8i9sNv2=2u<{w-J#Eg;e!){8upB1=Jp$5b>pu z4<)EIHbmU=Hxj1*{`I>Ida|)zDTgtFdDf|p(QJ?OmqTX(8Z(y`+=l5^g#*&yFj8`J z_SI0eZ_)PVFNUAHRkkTFvE>romp5=dYNrFNOsERqkn;Kny9vs+$(w zO9VtupzdL5VOJ4)k4X0KYSe1t4{WUhfjSC-T zHvI(}SI0#sB-`|POHH{${$E~wqPHjHRn3$qdrOTbdwKCv_A5<%Iv!!rSLbd#Dg*x) zc@mj&`$Xb|qvj%HVrK&r5wBUePB$huEB1jm;PQ}OEYSF}w|m%QV$jt{&2QvkvR-N@ z+Bq7U3THn~ne+l|qs9I@1U(j0dhetUyM}TJzx=NdL;fb{C8#NX@VjYnse?%2!j5sC zPuVD&2r@LLBqG2`I|oe^?0rc6(V_>KHp5hFx6f?bI z=;CI|iarQZSURZG#|w206zcI=jn`NUB7T*3R>&?WtaFeZC#)|86m_BdP^tKndOijP zEq9}rg0DHf-<Jfn!fvVha%?)6?YoDnCT|q-GRG^$Fk+uGCQNa-ryu0LUz|{yc6!5BexDINsV95*Y0r%ytF8Lkf(A75MwO z9knkX<1w*>aH*J}9=Pgs!u4zUM}N*Qj$MiIWh?#Rp0cGI1Z77~D(BlS{Fe$`d{Wnj z76TR~^Zh9YYQUYR^}x^PW2pemcIgFKuE~Fqd-HVv0`uxib^(o1Wh)jvEt^zRErbu(5m- z-3xhY09f{_PY~4Tn&cFfCfBV-?({k>Qi0FwDAyDYUiGiOG8qeRjs)} z)CMY8h`ZX*^13#EzEQ0<%B?iAz1ZezZ*OIu&){|#a(jL+SiXfM**Zn){$h02g=A#O zM2}X*51_6sHcF{|6}~5~WywcwV87aQB5si_%o*^oCQW&m5S8EEKw6z1K4^7E)EowC z$!}L#3k&a!8%qm5X9Z=<)mk|^517PxLEgf!2PH;XwteHY#S&ix%B?3j_J>dR!hNZz zA8=H4TlYbQ6t$xH6B^#oxFeeBF0lIU* zdh%m$^KV*wGNrB-XT1V*7+zLujz>0%ElhJ7H~im-YEJaDXRo^yUzjU5t4lf@*@301 zfFi1Kxesnu90Lgy#Kr zR81$}vF;AV%`V?^E8kHo#q;>f?g;PBZEQbHv~{T|5u%aD_52gC^1MxR5?|mdOS)!V zW0@Db-n4l}$pb4VzbYQ3W~2#eytW5yyle7Xax)EVL>=E+FqTnvB*?A~30pUt5Rc4m z9n{xQPcJKCBs=h5ED1Qv0>5;KD7g=bfD$6&?QyiHpZV?Fd}YWzQe@%C4|mi6>+r zAb5ycVt)4 z4AN8gU)HjUkT1+rU39h8aSh~GB{G zOH!|t+YuEwy{7otoAur+^#K?;d(Wzf>s*r`7;sAo`$$P28TPBF-+``nb4PJqGc=%h zOUN!N+5Us1+D(pvTQ=PU+g)qqx+4&=|IPw;gdUOAiUoo^Y zxRsU6UgH;iofpa3ckWz36xnCv>vyWt1J@ExPJwkD9-xyF7oae_c|XUcyK`6nkwsUy z_h7P@R$jNP$y8SOe(~7-iYx7ZK%w-*(OBy1 z%7K2O%{dRfvvgsof%`hweRu0GOq0>Riidv-9DKr|i2-q0NmyVA`e}HY?!8!?&X6() zNufgZ+`-imGQiS`Xk!l4pTlIJ4Qw-+&E>OUbe%v!|KOzSf7QPY_C}mf#DRYN9Kk@lSK6JxP7j=K02ZIXxPb&=tsTdDXP~# z`7n~i^fHv!|AQT@pV=c&JYF9v>(5V`8?WxL3P6S5R`#FZLLQFhaou?toJRE>oTbG= z(yO)bBJ!FQCO+3qjIt~trPBfOyYfcPSms9+h}#ssmX80Nj1kr@=+2_MooI-E-c4`4 z9n^HT{sh=A*;nGWs}9ekVQsrbSw+wSUEzWM`QS)QmP=?2B9U@j(-Bm8yZ^`S9ps*? zkmZoxpD|(EpBcjh-k=*-{FuPST z+!46E&@0|7smatqL-V##ShIZScFgF9^!BZ@-1v5(j44hKUA9@M{GxHrhb6%o_X#aHIC6u1+c>cs z&aS3v2_LGh5I8h0n+|nBd0z*CaAp5X`Q1a?GIAd)X5<@(=0mtXO+~q1!NZ-G;qX){7~?MT3RiOKPIKJ=er+h>3ppIF?q|g zxBh5pAb^R9Uo|^;7H+le3SjARRr9hVRQI}dZDICWWB;PV*p(5uO5#x4 zl(py|t(*P9S2kX-OBnB;#>t1IXM0Zr5*hit-QsOwhoWx7zOaX0!As3J+>`jnfR@ii z_il{yfV*h#LjnotHP$2R>X>zibyM+;h5$pLwWuQZz1{amtoJ(GkEi>D`<4EyQ}W4P zQGI35`@*CNq?-^VI=WFkT5Y)W$WHE+Pa$earCDcqDO#TF<|M5i4Jqx3dl88&#}Je- z_yG4B64l}e>5}hvbh2UK#t$4gd3P7AY62_+B_Hq{N^xsplMDY#Q+fC=ZO^)4kfW8! z356|*2~`tH59$4%$Q&B5ivbG2@M6>8%g0aQ*QsMly%45ag_UCz;)!ydt~?sthE~U0 zRj>OyWNNoh(QRF(@HK4uVx#gn%O7C+gc`TRR1s9!9JUcj2lu+R555^0#?#LR*TqLk z^9}CKC5LeQ<2#5A6bc2~ZLztX*}Yj*H@WYyvgUK7p8-60&CbK3|#%8oCJWb_}< z2~o3mcP*?CFYcH7P;gjSSg4hDNK?#648i{cRzRu0?B9R*nP=q9+o;jWO0RW^oD~yQ z^e&`PUYqdrgU&dY0rsrCIl%|%`Gyy1Gcq~NmRCF%^J%tDb9UJ@i#Uy?6;)wbyyhyQjpze$M=>r9#_#F`W3=NCg`BFvY4zq(FDi z(tB`@W^X3!(b);JsY#;v3(lzR|8%+3&PT9>9#{HKdtO-lf2{9&B*E{KS$Q+-9$w+)%u@PIR?X7uV^si;roY z)nisC_D2o-qlNvihW)RB>H0-3Cm96dTJncVR)b%?7wWOz#LtR|U|YYfl><2~>Mq%a z=S9AGt*7pAOH=_o!phO?a+H^&MB`DUfA>61?~9M?_B|eJ-*f$Yp4o5wol87bbr5C0 zOAG9Y;@=tfcGu~~B_Bcmsc||j%@$X!p6#$o|Z$^5k9H zqxhYp6RS#n9H-cOrhb{L$Qk)ph$8IjYlxk}5zSxG@3+@^G}hipO#e{1_$*dQ8 z`3BFcG5ldkj6YOSe#IXu>C^HDgbaUpvO&CFRTFRuKQ4cGOwQU99$v~hna2m2i9ggU z{s5s22h>n1>B#VZVaVU)j7 z+`x2kR32^JiHKdPb#4ZJY&m%89(%s`E+a3$u4ljOe_ ziC2I+VxDi8yN8v@&iU$n`pV=5_!LpJi$3|XK|V2ovoUcnQ((J7*j;JUYQlvH9LIe|Ll#mY*qkEaWHe=0 z@gQyK=^jf$5p}_9;~Q*dWJbCzAqA{-}`+I`%Hm-{t4_8P>xFe7je$(`kh3BNR)+=4^WO$5Aq(a8A4oTC10i(fC6N9 zm9hoAoo4PbW?56cRs0Ix#X_zG%f3jBIu;wHQxnO{=d+|Q`$Ej?a_Yx*pTN=gHq>+6 z_57W@0tiDiALS*loR6g-0oul+QOSY%W*Kqz^W;(k@}0Rz;n+zezl;(%StaipqQOC~ z4v4c#b~FLB!t)c!appYZc{$$saWs%p7xq?ddT4^4IO2THz3bjJ`)SMWOENN3pU<<+vvpn0z9Zq3S? ziHj<{#N1jHtPKX{Dm}n(B3KQK{fE{SBsd?_K-^!4oy?W<^&LB*SGh_W(mgz|d+~ei zCFo04HFX-Y%O%{PKO~~^BhmGJNH$Ovu^I0s_+?zwrHDO6zY9;In75Mq7e;wMtXDUV z2=5O?zcvNJdXRpm3U%z|YJ&c3gtd!`OcVhLCXwWT$N{021GtPcIKiTQoKsRKiYTo4 z9=jJgP)0rg?8etriF{yrddTv?hZ4nMER+*i1WH#Kj0+i4lX>|wG2fH-;;|<^i~78% zUQ!3!YWT%mUQD&g0#KSgI44wmlH#ZQDmEBqz*+#(?w)jg;<}es&_>mlZI$T} zJuX2D+BXUs0G~+*SV)~3LHOoGF;iupkU9vVD#Mj!7@H1hnGk2@t9Wg0 zwY*oj9^Xy!{bDQ^6i3A8knQ42(8WXC#X~$uFRjz(zHbtc$UE|#NM1=KpTjV!@_68__lbqu|gdupi7OEaQ z8kIO&sHvatB|kx>>OKNCm+11{fT_Mdg5lz!tF%K$RBv^y-Y?ZCTeKzR+Pz5Hed3kU za(B-TKVYDtxFfke|Jd=~c>Wps;RS=aIWhSR6?4t3|2BoMhMYJFM7Tk9T=jXB`!aQn zV9cTlmNWj1CIXP+Vo(75D1hYoIr^C#uT}lCXYXakRLXY>sw|=su1R5@_IFsBe5xkO zFYuldEHlnw+d~kodZAr&uS-*YHAgfp_!A6P8SByO{0d;%iW)qBfnPYO(6o!PVH!7` zA#9nyL1}fFcT1Uf>oVQ<*p6Zu6;J1KYSk#!kRVgdb}OimiD&XNC>vN?d-7oIvJ-}` zbQ%WN95t!A`pvAS@XeT`qO5i4{}tE0!c-z1=YFj0aNu0bO5}e#@?Y!bA0{68a$a>e z@b4=yg>R}Z;jga*{AG0|@K^E1FbW6X{TD9n)rh^J&ecCq+>L;~BAN&7xQX-J%)hrF z%_~dO{42-a%D=Bcnpc&!>9v6WOKINQIM?g=_jaUtb!pz$1Ab#^f8M~k-iX+n;{ACO zpf{J6^=80t5%|9t{{23bv~cSE_;dW!olL(zJ73wVe?Zn>krNd^$iH`*?@Jf$Q&;`G zDH-8rM|uyPhax>O)-D=U93zqW-zH?2Q6Ae>SDvMgIu-yeay3 z*7tQT6jyW9oMq>1fqHDtveUPKN6cBc`ECxLDxQrHz#Y(+K!m!NW0r4z8~<&(lm#q! zS%sH}jqhOSmMzEg-}5$~FX7F&BE9jY9N4zGng6~(3WvCb%N?wn!AS}USv*pS#p>?~ z>hFo_?@8+K67~0F^>?ZIyR6<6fPvWf{|-O%3>CuP572i_@{9A81u$+v0sL78e*tp- z-AH|+fIqFGb|Cx)}V_ZTri>6U*jG^X$GCL(q)5 zJcDOt(Y`b48Fy*~4_JY4zLx3VXYht^hiTfhRcF4Gv#xx}vc|+_Y+0ApB{pMsK>Nwf zuq<0vpU{30aNe-2LTLB0*2ET;fRY_aJszmWFmLe0yk1(cu6sf*dr}eEDQ`)sLed{Nx z%=y*FtK9P|gv|NXcjn9a)!iT*cME!c65sz>6+O%PDhS?5s~3A8r53GYIT;1fUQD}5 z`xlBhk^XIbc?IvsxSsG|Atio_Kd-5w&rfsv+4m|m4X^|2~Gi9ujm!E5St(-h#f7;WU;_zR*^3+F0N4d0?HcqktBH&qJP-(MmBw4W&A zLuj$t)1I`t(t|X0t~1w*gfUd8e=Ak-XpwU#WU*I$vhfAMWm;W1_utW#e}akTH5y&G zvzx?)HurlCA97gT?`?H#q4_%D(RPo0I|FDBj*sB=%02@=NG=pu<&9V3SosYcgEbEm z-}Tr#hHqq@LSpJob^7iC;rpAB5V}Jg&u-v54*=C~#Ga-mcng$3l~rdf+IMWC_B|+C z-IjTz+-(_sSLV#K<*v+$$+y<=U5MDIQ9aMw7`KM?ba1y0FT72w`Bu7nprg$Gsxr8)_0)&( z=jf`b|KRho4`Y7r;+2*BNS&NHB3K!GR2I^16|M?C#%En0SL>@=r~8Bjo4j|&^ZsY~ zyq~n-3k4Q@%1LR;`?Oy3y1dWmHP3nO(QAGoeEq6C_X3BQZF6b35Y?g5--k*3h)iNR z7<59AT+d@0AczFtyj?%=k)%ypeSM{IRY5X6<$P;xa0zbOFPz7oN9NSA2Z{w%Qg}^6 zRnSD)?m#KrY4c{~_cWiqnPdUReV!)HCPgQ2z|`}FCTp9!)O!v zg*TzN<8}1h+T;)GQOgM^^@mQW6(}`d16yB|il5|($a@m~993JBOe5fb7IwkEid>aG*2`zxlpbxd{Zv{L>15Mh!_ zB26Yq<2x*E!R}ywb?|v02sS!!(l{3uz6~{O7hB1{+g9+Jd|F#mRf=j{?7M71wZRRz zJr)IhK@d{t$0OcpwG~YJ*C!@cR(Ofy4p+)qYI7pkOC1UCQgXkxM{0@5b3d~3+=CH$ z?m>~~UC7gW$4-Y2bq*!x=ZX74q*L^!*#~mxRc24~m$C z0)tN65dN7+S%7c+Z=v!41s5RlCrp0uJ8>t@`ffmi#kvr{;Z80Q)KrrM_H)@rJ&cmJ zOGykW0`jJ*pGqeDnR=j#4VWGjiE1KJ>chOp;$kEq#n9^dP$D^(IXOb9 zX2c~)H(1-ZK2O4GMibijFr;)cFh{{_J#^kLZ8F|b0Rx#P1S$XSJH5$O351F#Q zDAEP~1Ybg7|ILVr@WSAK6#eEzMZ^fmxl6FvyN15bufp-^oz*PQaPKOl_YL&3kN({* zBk?f^BlqB0_e0z~4u6P#HjPHZRl%3J&X1e#;47fx?}fbgRmd^5oA~&LQ-oiu<9i%7 zb?qIT^6Pcw?oLZR3#aap_05%j7>)RdZN!IX(};O>n_d)c1Q>%&Ugxv|)_`$`jZ)QJ zsCt8~`Yv1DH|lH)KT@Oa13O`D5H0=|U+gV;tH`1xmsTt}t%A+)^3VarnE)X`?`b$y%E9HZ=E-+>Sq%Z7!fw zk8#vvCCz=zH1`DE+_QuNa&x6EOt*%ZZY_4{*72ouYoJ2@Idtn+<@SHuo%vZ@URGYb zVEX;vucGwm(HK4YwV_A07m6M|Zt0Q6%eEL^K4J0l&k?-*vx}FF3NN3;2tFxz`4@aY z6~oIDG=GFTbO-nQ&s7l}2kzd$PI2SE3a0#7Fy+Z8rue$fIwr+`fTL(l_dv(W)Qw0&>!AMX4p8|QyS$M@;j_#UouZJcrTQN`O5kCg1J zpQEdJfDozI4?wbhj*=|+BkN}#cUFGuov{XFs-~LP4~nwuhijE0_4--ouAenCtRECu zvVJaf`Z~?}SvSM_;WF*~a`T+|ol~vXk8QYGKir4t`nf1J#|?IlkB!XnvF;qVs5zdG zL7Ojgd>pUfTl-v!Rx z0y1@spvke-F7K9_q#}z^Ckh%MQuFQ;4Mr_gjlTo03+U7$j#^aG z+(o9jC+OxX-p$RGwm7_di;Iot&5Cy)Qw}e8IrB3O@7^*4ULF(0%VT4B*{CDqP;wq4=nGK}ET7%pxVTs*av@dnAHbQ@=_Qu~eXR$<1;NtFiutVTyK2#3AP66+gZjKYa`5OJctEw>hxoYuZdiZE~)-9ry z@|=TwPn{&lilJDvpz5JjLO6K{WlR`bf5hjf9l%yfBnZ_8glec-*{Yn9WAl$Ainq`| zjKemWKK|cJD&(Jo$0x<{7#f&fXKvNQJiy_3FE}t2}Fc80ag*Q)A~%l9q;4|Y zaf8j0C?XJa6U~^~$YJ?i7vqHjJ=bA?fK06s9BHn0Wif7%RL8Q|OB2aK7eNN%ve>u2 zW#)2CIsDk`jKeheF*pN$tcl`Ba|}P$8vL*gSNO516hE#?6wed<*vzS07)u6^2A04c zF!~PH2sP_^en<>w7>Lt0gG-gOew#Ljv|G9V*YO{xoU0MX50TlkscqGA_b55B0Cs){ zpr8M)IzPF#74!E!b$+75-&f%)O7h&;SK(Ex)V??`;ql(4C$PRoA4oF@H!JSwtMN{n zYOS`mvdt>?2dWOUcS#i4t$z`o{*M!1^^Tnc`{*yW^DmtDO9ChVfkctr?-$u4KYthD zC_eeOsBiKs5=C|$T!c4aeitE`Y>3vyzJQB6`4>)tC4mLXQ-=QgWP*J}Rs}z#LFGG0eEmqN0pXHT zd_+FLl;|=pkbO-)D3frV!IjGqR~h^WTE%{N=)3~R^LV0og`VV1D`koqum?#7gi3JM zA_74k-Y>7jT9-Rg%_{j13|?`%L=kDiA2VLzYTbn;@KXGT{cX3B8Pw?v4wNgCzlRr~ z^$eBQFV2$#oLBNmDm=Mt<_kuAjH7;&f1peQDSZ#iJy-pHqKGSGMO-zLTP#J~EK_$e zok#@_9+J*s4-6lo`*>~qq%LxH4;wpNz}fglp~*iHwK}X1#Cm}bSbkc^hxUlvc)5%= zKytwHGs%KKh0{s23(l>gImhw))X#Z(@yo~Ynn?pN^>7^@!J|w|fVp}pn+fpkiR3S! z(boj{5ek3+Yx;Zdy@pnzyb}6*snh3a=r78j?ri;G-SX(!`cHUZuhGNB?NxM_n=W+s zzM7A$_~m!sJMx9Myyu1cSA!3VFs>eaWre)68T9`~7BU;MH=mVWKYjyVTT z_Pnou`LTP^*<0yfwr?^l_+w4G{VbC zt{J~3pb@<1XUwY^#n~ysC7k3@?^~WAQ=ITG* z_L(<4@!Ge3_^ID-|JGCg`{!RgQ~mAh=ic(F`;I;O@}Hix;oaR!{GG2m`R5x?SUP{l zJ*Ter?p$+h{tsJU`pOHp&3pA{Ixnoh>%!yG*L8pLS8IAcddpC)Rz zS#{Z6*-I`v@V>8IF+B95!Hw_y%IK3{?7w=;{l%-dKe}P!4R=2{*}vq8Yab)Ty_Nob zmj02r>iw1`=m;n(OzZNe^!F(moAw&dD^T1gXn0mp_&+GkVv48jtoIVyZ#_nT zn<(ul{X3DuAELk6N`4a+{t!K)r`|6Keqp`m;k4((8X4-9ROUM=ZULo#AC)^w<-V0* zpQV2nQ~F0K-8lVwjM5U{^}bAL_R;sd33f*%Y>_?hG%E9})x3}PZmN|h^6sX*M1H-? zDgN)Y7Y9D6b`6CY1S03YokDp%g$4hA^M9X(!@|@*g;vd^lyX;Ld`IIT0fhNrA=K< zBX(x_tlc~S$T&fBWPQiN|XG36g^J=p~M1@`D2u@ z5iL2OrXo$l8Bn$RY2>p63+cZLXckW|pQw|EvY)17oWA~*61ME51Uc_&nhyL;QB{*( z4@c*Dh-`OCoAU$0sa3jwU0n7kMW?6D@H#@e`&z=#@MYgX{^5)qm*R`BP9l9b=hc*D8(KH~JcjY7XkvNR0_fHBmEnTZ-h2`e7ureRNeMxcFfs=y z>Np!^@#;r#;BO}M^=pP}_uDC`P`_BR$L$Nk39RM?ox=4qQV**NI? zxyDQ`Q^=&UnQQ!XBi#fsiuna+JYPvKQUCG*i?RGV$9D`M{Fa;Q(;J5Mdq}h^+!?#sV8iz*n9+eO=ETD z-qyykRAFco!!zWRgT&~|Nag^Iwk`D_O$3S^4kmJG8U)i}ssJ<9RI#Bgn8>C%Q8pMt zJAEpmz$K;%h1Ae!BX@$o+%dSM{m^(Gvq+^9fZBQ>$R40!O*IZ@d@52Vc~#@V(F|qH zNJGMj@$n#E@Y79=dqQ8&d4{rOs5gW#O%)yeKp~nOwA0LdD(8#_+D6?Rr2eM}b10Y# za%YErDogzu%F+NfHCB8+(I#U`^O?_3uc&2QAXwA9`rfRc3W1%Wl%;0|-2*DC63wV^J>hwc#Whou zd$&L4j}7{HMs+02``oU^5kKeWGed+m!GTmhlgiPUWMp#NcJ5x)7zT}#wCmSh(_?6B zq&9I)$Q9(%zQv%SR5pv&g%dP=G))zsuIMMQfAvHv8#X3S-LmCW^!-%&LwWaZUqQo= zmYhM(48n2(E~nIIo++tYbLrM>7??bm^%Nm4jU2CJUlu4eFmwh(b?NE}KTpef+#kve zX9z`salS!5LZqC{V&UguGAkN)c6DE@@pd^umdDVr;*f*K)P(}gHgH&vLrQ0kpz(oB zzCZ)gm<$g1`Ftjw8qE5pZ+U~6Gq-K&E}2~{Cz@~~ZoZW6AIgM8+OFJXmmA`#?s3)v z$=abRg51d2n8$P@bpkVu=469ZTCb+_=G8NK>m!mjo;=jJWozRhl$BhuV)MNEie|lV z)u;}qGFU;pKp4vh{n6Bc4E0D5ve-OTu}rG+(=uf!0b|AF6sanfMiT((^k6dK=%L?v z^(K*1y+faf_B3Mc6dI|{Mkum~k_=81n4%TeDG)D|irynDFrd|9%gPa9$Tt!?(gGOs z(^6vhY)c#q(89IP*21nMDlgi=SW$zsDr(R#90cFR;9-55CN?J94-I7}LZW;t{_pDO z$~|ixvm0Xn5UnC$*|Q?S<+Ca;92IWIlTN7Zi+EzDf7;?(XI1=+GuP6Z%{m#wNKPiv z+#n)7L7wQuILIln`4CIDsbaa3lCZFu-fPxAL}FG!#HwAv)lC&^dL{}EsgaU>2s2>r zOwm|!ND&ue5vQpl*{ejaQc|RvG~ySCtC6%deM&{NmX)L+vUM<@DfnlD91wXZmjI%o zihuUTgsL%F&EHd*P&0RsS(aZWa#?UEO1@OwGcPjjv!Hif^je zm!#GB2ACMgk~1-Q5y~WgbH5fFO`Vys@vP57ohPX&llPrX2NQy1X`bPHFlLjBC`u{+ zR?#0Q!DmtspV|mXP2>POP->~HYMcl~oD!)(ivvV9NuC=eT$oNESkbhb@iI&@T0%Oo z={o(wOi3HhIR`DLkisvTAQBoTK;eA1oW58&Z6p>9riS(>ht$UowO3-{#O(QM_-lI@saRX!*P(LlR+ z^Sr)nggoLiZ z^dnt`{Rud+_dM@(&)ePC+Ki*>3i|I0onQXkHTS&nzkhV<6^}pp-|xQioXzWNzWRn+ zue?0*sXJ0tfBwe(;f3#h^K0)rwEL+C&K&NaX!-2xfA#I(AD(;Xk{|!|sYRzB-}|%o z-gWB7Mjw{`2Aa3$B0qo%SK)!#g|^Mcf4Pp-T#^T`!U zzxnQMKVNWf!!O_aorbNixnSp0RWJO~Uo)4VaL(Wh*MIiDxrMX8^OleO?qio_w%>B~ z_wKxJbJzICzP#$I&3lizvE!q^z3_|gI(o&X&w1@XPo4jVzb8I${-xhrdGk&4pFaET z=caBu;hN2_J?BRoMy`MNzwDi}=vV(J{@~@Q?!VsqgZm4ot(fZi(LKNY_@kG!+_3Ax zO@Ghd`Lp+5`-d}^uln=*=eK=u`2GL$K<$rT_+#&+pO3c=-*f9NFS}>#w{2(tCI3`n z`QA5nfB(T>T-N)?rw_j6$F=EuKKs-E`1Z$t-uA==AN~BTFMIrDyFax5itzJ$d$(Nl zXlii#k3N0!wU1Ue9>4UruiSFX_iy&j|Kz$A4?O&$iM3x{kZt(-g>y1jEvh}`4f!|L zU-$imZ@9DhmbWgs_4)@^SKs#J6%Vz)<&k2`ub15Rw^fgx@s4z=W%HxO#|vItBKI5b z@o)Ta%ja*~`|GW3XPx&yUw!7CUpsbi|K9W+zj(z%Pke28u=5oQZn!1+;+Oom=PyYL(_iy@Jw;d{`d7= zyK~+bKXv)~Pw(7t@O?KwdGB|3{k6ULSYyqGAN~6~zPR?9p5x~~{L?SY@x1MQ7jCa$ z^99d?Rq+8F(4V_{Lo;9Cul8_LFDtxvE~ohI z*Zk38KMo4)^@IGQqhKb~jsguKiOy)Cf6!_5_Ed;pwG;JrQ$}cb zyxqPi6g@peZKJ8&2-Ow^P=cK#nd)!REm930Xq;!179KORfdQ|LXnZC|I0F-LcXb6j=ft zDjf2Lsiiqqw|0smNE8L!BjVLjprzbiCY0%H>pQ(=>!yK$HWqNh{WHE~hW4lRyASBPw%1ULeEaVkN^TENKUCzwn zwM6G>v1FH$2nd;aNKogYZpR+WezoRD!j6gDP!!S&!6o$cHU1Ehmr>ZlEX?PWQ0rM9hoc-O!=6dnOvEeem^Ws zSDxwKbHk>g*(IZjE=Yw!aLeN^6G2MurG{zsNlG)Pv#MhgAp+qn&2?YFA2)%Wer}{N zN*$dXqK!*Qy~H{WO?ITfUM4-Q;_#dkj#ho7;py`fLmw2KYbiS)niY^3>-AutJ!Tx*--G(GEyX?(ORYQkh(nUJqT51X&U-< z%@`!7vwCOMy!A9Mw8z1zkS+q1dwe!P92i|4DtJ4CfY<_&n~(|?6*6!4LV}6$;jUE9 zd@IXF&*%s}qmlH8pwJApEC(h=@yUSE=sJ4ZAtpPB^A zbH+*UXgoOpnccW;@P;Pxc@Q~g!|Ao`OofH=1enirFkhwE%@xV|=oy!SO49UA3=d}x z=}LLs3Eh;Mg>LFScIyz6Yo)oOD#wIob_99qtOremR|sa;(RH(2C2P?EC|yu9%OLHC z{Gka1dmuh(1{H&1z+#}5Xt)$9E~aTBI$w^McZJ;(*=$)35DpQU2tkL5?qsuNa)apt zDcXTT#9etzC&p=&Q9fEEg&qDl@GLi!@qzfMG&B^T2q>cu<(o3PgMvB9l7h^Fr8e}B zX39uLeZus^T{KLYo&Etoi&i`mlYn zD{a4J2!~}&=ZKw9q;Mvt;36EhQ);m%CqC(egmmi~_T)1jW!X)WX<%MH2nyY{4Wp^h z2_5Q96-E{B^7vGm7Fy^HlVm4kYbYz+<4~9pEJvf!C>8?--1 z3<7yWZj_k|&Ez|>DcXX!1+;*Wf9%ds;E6ol+rg1+_&#;=+ePdZYs!%mh zkO)FbePZPB*`3KMH3f!}LT0eXvRy=83mK9P)EsdVH3$PUHK>yI|8p#EDl0`xYi@gNkv3>u*60;1yIdA>j6R4a>KN9A^|dwHAS?Sh%Hg3))BvdloE{+ z1NHX%lc7hloYx=FTotmkD)I>Im?R>U8R~@;+3Dw6!;qL+cCy)P5xQS)N33Ma@=B`? zznmD`(g}TEDVWxES>QC4@5!Y|_#VmmX{I?X<(p7`1FKm9p?gNoJ*ctF1xrh?{J)I2 z<>Ta}to{mEGp$OfG{T+lGJ<~rY!k{8{@XIGgxVcIE22@`;xu^Y0qO-)K0Rjv<9#f= z6C0{l5uiH#0w;lbs}0M?F-q*!M@GUAZ4RS~R-iry)Rh~~r=$dueDp&^1GR03E=z@oeY;y`)i+rpj(+jYhdlV=?J7c84|gp%IrEc}+;`&>_(% z9h{ZmO|3vx98cQ_861Sa4A5rzBb}X~WF+ zV4JMA9{AH*z`AWMunOpa&mRz$Qs#&uE#1?&P8>yTA3c(*NZKus5Z0d0)1+RK%IC0% z0;+XzVno)iXwXBWObzuG-_ftj_GZLY`CDBX)CL)?Css-X5j$IE(gODF&y0_2c^Ey= z8(3@GO0wMuZGSXsV3D%v40CW+N~^#90ZLO_E7^O@hAa$v`b!wJl*T$~F3C~R&^}QR zQ(|ly%e}S6gzGQFBGuWl)+0)N)HIyTYYlq~A3600%t6a?l0%cz>*a*5+6_;dyS^(m z&SzuZSZdtEfjXD6SB|_zBOz1PDcT|EJYpK4Hqqapjs3xPl6?CEFEdOl0&E0d_+vJc zvR_n)q?NkZdNF!aN#F)NMAn?yp2DckYuVdlBYTfcy#>*D0J_q4umhCWsdqX%Ak`V$ zn65rG7%XY&kx?3vazoZ36{Ry_N~9Msf?;hp;y}%6@d7hi(RCcUvm*PmW_4!9z0dg} zbmb7m>{*D3RtFP;5l&m5m3+`d2kD8dua;7Fj3qgo-i#F>l8V}MP|pF(&Uy3iG#312 zyJ`|IHyuF2_OVPs=|&VP3tdtHP->a9o^h5Ohv-N5PZSLOPAMb4I;;SV(<=5}C6t%+ zRo0Yj3*}oUmA$-OZ7E1GLuxtaGb5v-a^x;EGRd!QSSIXa3lmY!I`TM^FV4jk==3dW z{ggdBP5VRHl+l53iK2-h1dAOugkGPY9rk<>XLYDVa*EQ>t4xqkwJ0rWT5NbVfo)6W z`q)AnJX9wuRV(t2MK3yREP2jodeuC%So|q}YSMp%lr^O$NYN)wDk;EzXrs+V5q+iI zMy3#zH5^>VNs?4O-KkkmZn}6TB;`-yXtqhL%?4!-(5x<9v_cALWjToflG8r1SoOq$ zP#71Hvyk^fLdeR%SVSH&Q|XOm4rOv0lS2uH7!q$sdq?Y@o&5tHT|3(cx?6X(8%S$k zU;D1@J1-TeEP1s|FUb@}Elxz^JTd3jh{6dD`lQ`FOv86iyIiKroRz!QGKs zc8V${OdarhM<+v)m$JHKrl~X;eT>jjn(C^fD(eqg)5KmBFVez+WfU%%LtZBLEf)kq z8FL6)T7FrQ*`hg+=(&XRl;^pO`+DreAcTK0#!3({CCm)7rY4cdU_yxzgeWAIjSJ3% z(PqV%ozklsc`wTRDCBZIQ7AK^p%h)Nzz2nu!a8ee;_}7zTu9q2*5<25c7ps0;}iXv z0|*gt1U~BMC^dvt*5%88wgimHY8J8Q##JG&*O4##;?3!c*`?UF^+nsJ`qK~df}UJ= zVEZQ-JBV9|7Jp4SU^6UyxTFE-Rc%Ogqb8`@NhO%}Y2|Gu=bL?Pr+{twp70|D_xgf- zK_}|Tv%Ce$(K;liydEz>Hh<5{XDYy(z{JRHRh#UDxyzfIoY62uc2Us!FACe3h0(Jwv+08XUB$=pz%Pu)UB z)}Z6`%fodFTA1EM==X(L^pRD$RSY6*6hH5x@8M} zU@A?Lc+1vx0|SN83=Ix!Yqp*{Ft7oPQ52K}ckIT@WH=|sMuyW?9A1kon=;#My_`#; z7?Y#hwRA>~O^0(NByIQG)g=l@BiOCGkm1ZBKdlZ;4v5M@G=HTP<*^66h&Dll%Jlyc z+7@G%V`jkUwL(WdwQ*p8<;QTNmhoBm>kin0!E*@HZe^YCi6N1Y#16K0AneHd{j>+| z$@y&5sKec2706|E0e8As7e8bSrOX$ImkrSt z(NH)2AtX>Y$m6R#RK0-pS+=8|o1JEFmgm6DtG$3Nb3)BfT87vZihJCW!QW<2X|23A zh5PL^&q9#U>n`HUo%z)GC{Bz-d%rix(x}jf-88f@Wt)JtraEx65UaVju!#QNf-kbi zkVfk1%@Zw1>r<6z$foj0q~dyqMu|-v&;KcASpM_%b_zdKr>_Th@&{w0G z=I+~&se~95QOdpQ1Xe<>6c-+)sPuVpk9?f|Ybi3(MPh#xl<;w({BrZcaL5rRR7 z5a2+C&{7X^29~R4ne0l9TZNd_ekyGPpOAPNS8Y9L(#QbWp#DVDNNVQIEWQVAGl%Tw zu>D-K+T+`A?V@`d%8C{j(@Rs+KeVtIlYT6mIuonrk_ylVEsvBG#;Hp9lR;Rv5?g+u-*kgVMnrIqIT?mf6(zYC~ueHSNpR>6D%G6`80;rl?2=Bt%{E1jb`Wu5aXJpb8G~_yQ!|>a^egP8uuPj0;4Yhx=Hrq8-^t@ ztuRWWSrqoCcR}=5AAfoMfkL@!Lt z2AnZ*!6lj8A#mZ*G0-t)5CnixFkdnZ5_CE)fIaRYu$34T!Oq-n9UK@~tzfpPfUb!^ zo%SNKIT9IZG@{pfuxBC?)=ztnFw2Kk*go>QV1lKPnKeH|1hpPL8b(p;h&VEJ>=~8~ z23xEv>KR$eMyJHf-raVFv9QGJ%Qh<71bcGPl6LV`R6}94bRIXe=R!jrYsmGEa`%8Z zZMhpg(w4F@(s}i#6$^sDFcPhKzmM==HALV-H@_4cV-njU0lhBuY)h@QjizN_b6$))P%3<}z7OTO7o5}~e!tqbM}ua& zD;!Bt4hguV(LjWgNYG^^0&!@k02J+10Zlt4SVAscu%>@5ED|Uw$fc()ynK0vo(jNF zQ4>^Omajd{DNRm1qXA#42+fyhRy7JLBB6tw&WSv#ci_AT zU0BOBi3OQDjghUEMD(!eursCF09i*#N1coacKd$1owlYyNYtTD!h~h>x&c&zLa7C&p9kNKYS^+u;%!<~- zh-^~pCE}zP#B9ZNzOj^2YWQhoWTewMD^G)rN~6WhyP_$j<0!-hm-9kzM zr6tKXVEDwMXTr*avU|`M6HNf!l?|1-e(1Fpb_HR9?_L6z%Vj` zeK=gk4v%;)ed`T?I#i1s{J3#8f|;4=*se?{_p`b}rbg;?Id6EPY%G{(x0KI{nNQ6W zImkm4y&TECih)4ycBXP86EyElUApz1tlDqkoBONO&Hb&$yNTt$=3KCacftx$OQHea z=m{2i+x?MDPJOrM(&}qB49!IL;ZMO~zFR4iA)np;A+gZz;4{5Gt;QEWR_YH#EBO+U zQx1617g2}85-Nse1|j&vQU!AlCdzj&86}b_;z&zrVp*0-^imD%4-83(&_P`!<5pK_ z%}+xcllBi0ZN=grXAMZ`QR`7BmXrQgJgfB}k#mMC2}xKLG#vebAu=5}gaBhfE4b>G zX^KH#hAi#jjDY!NV8dKu)NVn^q-yeemCZO`F2xAhTc)0s!Cl!8GQ2B0b_ar+HZ1;J zD7#Hd0;X9@&NuMF399{wT;8T-!IvrunZc}Ykb`-GQo`)_?aAyOHe@mif3q;OWwxvX z8(3q;SC8pxPaCzVzdd;|m!cpM!JgsWIQ+3!N+V!&%+E=5aX+x(y?al3R`nPS>2_skk2o;t^6f%{C78>W3_M=HBKg@43!bJ z^yS=GSc%C3(Sn=OHxBagNC>~Jdt+CITgt;#8>Ww3r|&6;vKE91_U9*r3+pt?xh;)bLRQkuD6oElLZPJIP0biP@ICr9qCOA7`ouG6NE9vQ7T zCfr4fbGzLED?uSwh*~TV-tG-DQd(Qoh>Y)Asa0A&I##%ir#bF`(_V)2qU#QZEkw*A zDN&zx2BF0eObOPu*u=zuosJHb82QyA;c6kOq&Oszshv4W??Od(VWBg_{+%6ZhDbE4 z6wMaV?9^R3Dt2<}g7o1kGoWCXa)Zq2S_?bj+H-~|7Iw-;v-~q{%yjv-i}OoMTBc89 zsZyCV?c(6FT$CIbmx*xNB->r9B-T7t@dAmNaE{*vrQ0Ij0+2|vPgedqn5W_He3sKy z#NbA~;llf3WwS((=G#8XFQYIQS=qzS-sp1bY$H-D0m6jsa7r*JI2tVtG6IDQR4mhg zV3m~9d#h*>9Mxl;m8m^F%ip*V7FdJI=*rizVt3V{En*S1Cub}ecmYM)=s1px?IE0) zF2`Hl>{2SMLd5l3JRW@vsx}yw%p@~ z20^^l3DNg zDVkWz7qTp)emS`Q5+DtTafqRrUs{_RxglrEU^F}(gaGESO8t%9TZ4dX?HNOHEW}=4 zb!dmLLJsj0**LbDm=4|-hZ_KqFD+P5sK@Sl(a=s~U!eB8El!V=fE9x@Gen2hMMCR2 z6z#oiAw?V#dl`|qU`0lZhy+w&;;FC@JL$A@5=KH$n83}8x%4;b*vdsDsW48P)%?5W zr`R7j2D4&I+liA7k(L->DWsFC)3{1$nKr!$#+~Yr1>0u%&|-os6DTI_X+|t;f}?`* z0e!g--(5Lhhk*NW>7~UfRSt(*tOz0V(ZYpu>u5qXe9bzU9CjJO1F6htWKpQw))FuZ zDtPG&^+&5*Nh9V@NT^Pp<+xdXcUyN7O3l%yJyS5}QUNKRH>GmR3}s^!RXm6LQnVk{ zxpxMsvAeG#WI zZNd1YB7zaPbAeUaScqiu z6XB@bYU!mF#UD^e$A<`4N!8rzTcy03%Q_0;k(?%~FY4N8J70Z?0ih-!>h4x#JPk>; zjOz+e_HJ&p+(?uvJqlBGXqQDA7fe{`5D@e@LV8CkI|KMy0*QmQ z74|Z&c&NX7hJ}DR!ebv5WbX(tjkR$+5K$NiP=Dab1#eNFtBNgB=>9p=s_$E~4w&Jx z7Wk968votxW8)`DLuHVlL*P?s*jw5o(6qY-*!0PTz+TGrWi`o^q{P9hq9`TslEjw! z#KB<%gXB+1d1b(qm7Quufdaz}2G&w}QV#>O1lBJpRS4_gWm1&BF*4wQZ7Ksxm4OYG zfemRGW1W)GTTCmo01ySNRheKTiSP!GZ#P-P(l+IMTpl?IdE=!~x3ayl8?(rc*-~$}ui3u1C z=a6ELF6ok?bg4lkx{t7ywINX`{b*Phhjb_DGrF%Qz>Z8_QB&Zo>mXR+s|)JDr2;kz z#9e!7uza_Uk7pQl2DN=K4DiQtJufyzaoPe zf<4spS-6(oKCcomuFtCgHEPq4YbRH%)kl&cGWoMee`IZ%fzBUc36`uMX+}lGXPM0q z?b%l2(&!_|bA%+>E~#GQ|F=ow{1KL*Ks|$O5|IbWxr^?fSK91GQS02oY3R^2G9C!i zKclIZ^8E8kn=Q{TJF9U;<3DFU6dC=e6$b4Wp8>@8lyVjjhsuqhIF#6s@&(YJ$C-hG z%gZSd2#WzWY*t)P&fQ+fF1I|yT6c-;+Ma{*k1$j`9V>xWDQ9MslViv$ZJR|}SE89k zau&O0(*z^v%(@M;7mJi;w1uC#;YBxlEoUt6kt#`5_9m@~C4|tQn#rqusdZO2px@$Q zjNm2)T= z4d*4w#S43slFv5n!b8PO3>NafvX+1&3<0xBQpd4}VaLl3hfO)V2uZv7M*A#~6o)EZ zb`Hd?NK<55ojo-knmxSu6uP%j&?Cr%<^N zR5*tipno)jy5Sia;C}6fRE212#4|=g0d$eDbiriw2ICXB7G^&9DkUn@0JCZ}z^+RT z*#Su2PdiIfD1%(#;w${J*XR^?^;uu`8)E2)4Ij)UoUnU3Wv>lrH$IM3B?)y-Wsh%6 zguBwlosRk7p{KQkL(7hU$k0Tn*q=|$B4bPlulM{LA*7vV^3|$$iGu|JU;5>&Ep2^4DBnxFqrUKCbVGGh zNJm-~DX`wWnom=ajHU`o-z6i>1T<@SC<7N88Ft{K-Y)TgyrQ5b6OS*fXl%u}Xg#-D!4 z;K*253&3>g@G!7NuDMzhUUt}{&J&oLO$>VaFTjxhl$%~-%>%d=GL+#T@>mxxF0ltH zU`~|qF>5yDyf@Gkmt-6dFh^3J$+jys-sEodU%QlU!_o%L_ODUE)5 zfs*LYKKm&NG%?qoefCo=YDXUJCV^UA_{bR(m=aQ}i!>9<03x@1%O>J-7!~W~WIww? z`obndVEBSXDiBZI!Gp%faCvNYnMHFxjlAkp&2GpRo_xDe8OX6XrUUkxiawkcYy1p9 zec>40D@T%IhL`pnVOJi8@bs<8PPRr8o1~tcdX`0=N|Eu0$0aJd^#Juu4Q?5$9r)ZA zV{+>>pMZG8#iS^>I|hE+2xisl@el*($}u7-Z&Zay46~ZDF>EZ6DWAveT%0Jmz#(#Y zXXbz}{6?UW{T`L!(qhjsQ?}S7ug?U97(`8xrK$=Lp{aP%gs0xtA^R38P7j3V?qsap zv$Enhf~?wC=pcQ%|bz&QSIPoi?kxhh&h-tkT+L5)85me z49I!A!Xlbk4H2CSUQ22tN)Z=1jI)$TN`=W*ozo=_(cQY8LDz<`Fe293?S2itQ%DiR zWC2FeSYYmKq|zoN4N{wzcCBH9CA1n^_3{%Bs(lp7Y-yY@U-F|QarKr!O@On>W)68} zmh@-7U^Z_Iq7YA)jn@Ol5EzNMVc3+%VYWH8kQj`z#352bPu}H21yiPyP?U};l~)5N zaYU>Fz6TnMkZ(LWXYwgE7iM|=I{Dt6Iv8m}q~11mw9KEZ&fp6hU25k5mMW=&G24A- zdkoP_<|~A8dpK%(ZwB42EJgye)MS=gVuP-X`O6HwGU_iGUBEYZEnGXNN!vua5ey&3 z3k1{xHZ@6$c}@&I>J;#c)9Vt>(D}X<7<=h`PkRlkbq=3zsS!)iNYV=oxr=c~bd{o6cVt4$=E@3hhjk zt>2;`3DTy}xd+6cczCBjTp)&y=ON-z45YqLig;8vKipxPD4JG$$*2p0YWsRd8A+%1 z$2dfTe~|rlGe?uEuAXR0l{Vn&+ud2Iu4}pw0>62not|s zf~jZ@bF+n1GMYxHwUXx}u)c}G9JiQ5S~+DJ*^0Nk)gDigE0(vU@v}ZPa17X^FIhFI zvh7WPUiC_uh4h*C$}CJf`w!i8&NX=hw5yj@1JT#~beDASNV{TR8k=N0qvv`FM7CW` zC0at!ox;GJqR?fYUXTUx7|K2qd24Pq&`QMAL5k(mQrFL=vz7C-_Rz#z1)>8ogJ@uK zh>Zr=t08YiyeeVqG%6uQ5!Og{C;=|7DHS7^433Do~b<{lsw{=jY`w zZ>#I8`c7$+Hc^HiS=SFI%c_~WoboM zPELf4^Ua6^p>8OZ1Fw}Pi_fUge#-8}zHT24Qc037dSlx@B@jkJJdkQb?=+${v~QUY zm>VGGLm!c7FJX~m*-rJ`tyF8jBX?a*K)9}X?~OG<+GPR)yHbbvRXP5KLmTz2rBJCw z%b%dlN`Y-ZS#s=B4}v`_SaBV8lc`^z5|K^f9luL%K@o_1o*9Wy&(JFG5SqUgQdU}W zQ#((2@R6_a*WzY(MAWkIKG$D{JsH+o{}Arsh!?q6(X!5QZ$=LA)QpQ99Klzos3=Qv zUSO6haF{CRabLy*H_RL0=#@z)DBELmSP@2pyj0ZV;i2;_l)-tYA&di9?>WsgzjCj9 zx=4E-7)c)kajMAUzsh7F0+Ljbcah;}%-O$4LrY&%-sR`v9L?zwL!1;m29c-!qAr^4 zB|M7+VI;(hFZQ~y_9Ynw>NnEN#AwN9lzwa% zV>d4cW8on$eydm>ymqOobsVYzhBTQK8M*s?3YXhG$tw1O+r@)C^D&L(NVK#$RNo`X+oeB0i&_yGe1$%eeEL zbk87UwrDdt#nv>U%!&X)qV%I zcDWL<0hTv7%S0LXDAdNGysus5mqJQ%yPg>Jdz?xmA^L0myqUanOp8suR@NQl%qyK@ zogBFagI8kRM+kfEOQd=^YyGo+H(1-bsUstPJvy|X<#QPfV~ceytEmzVbrQE>Cg@(` zmyTJdF(#4fIHRmHY{r1VzKYyw-ON~lEs~)tC-#V0c1N!V)u}Yxq2gQ3=9C#^ETOt% z{w&1_jpBy8LWJqbeg{4DYrdVzL69=S5xWj2bEkF1>)=)d;`j-Y0n(XmgvD}hj2Sh4 zG71YXn`Jjv&WOtM29Arw7_M4Se_))Ha_PP9+veMYG~t7J`MOJ9z6Q%Eb&;&!^k$;3 zE(8nmDL?oczcfn5(nxOTbX>0q2b4W!-0_%wGFACzPzkyW^=!?F3q{dc1n#psUW-$W zh)%Rw(oe8%pX?v?m3AIT)^kyRu-)&;MOv@k&30bMR(b_vBkMY)%%$}NMfMu9XFy3R zXqj=$rKP^n*fqSJX}fnw8k4{S9R&%e~y;ctUjjbY<+L_2KkU+){RQgB2ugaXz8fix_X&sP2IMQ+xb4 zu{?b&lo7+LsUIhyHRe3>&UUYIz&2xSXijW^@-l|*7E0lqmQ@Sp4PS*U3|HNBLHhAr z7Zwv>guSY~n)ZqAh1RL7P0 zUeFd-2ry?C?#Yf>Lt3V@sM_VWLXkpG_c@%V(}l<);ini3V&*j#siAeAJlB0R+Lki> z^<37?LI&4%^3lg#pw@2_l4oC7*5_H=8m`c}g=O7-mXXNhegz)=+&<~J4h&h&0vj%U z?^(yh-$_;#O|h#csYN{rEXSFoEt%6h`;RPGH^TD>JL-x2s>#QAACTxpqh7G(>E zZ2?><=5RXWFm>ZwQHIe3*-KLy>7*+sF6LMvAoz$0#(9G62vZR=k=}-N-RFA)_m)n7U~;%lh=T~L z(Of+3KMQ@_VC*5C3%98#dk@P2Ii)KlIC={dB@UmJ$x^6~X zVq`Z0tFm06?(OzTW30ySRIm)=BrF*nntR}>Ua&M;L;jwedX>XqUrOd_D4SB(nB*p? zx(8x?2)onj$Vpf-;&M_DJZ;c5hVU-fA$8P?iCh6UYV?6iI)ZX?@Tx%;#~tDAP$8ef z4Y+(>9lvW({3-e}D1_IgThmt&DoRsHTrR+H`C!RXQpptDrWQTww8RqIWPKq8=X0VD z!PxeUo3j?BT~Q;{=exQTSu75qPd|&HZ`JhCjHdVjjutm$-#v+{OrqM7%t8UtJkmFo>3M!skEPNg-EitSz$tF z>{!hnr}1uBuZ_?Rh|CZcx`y$(9Nvm2fLb^q4lXmeI?$81uXr&18FX;fE>zfUkkr7r z5u-Nh<|Sb_Oe<8G!}Q5|(>4(zZQ(eZ7cq-!{C1D5OPxzrPYUnZ1hoC8xi>N4v@tC+ z7U>w;;C&uv4O$t*>pPe!42?47V^Eo+DO#awXdE;Tqd`IPjCp!MRkt zls5|)xNMKR7NLl4o9q7%f9GG z)u&UeI}D>iQG3LtB&}bMD~}8vaia{KqtVLi=O-d+h^StIwvc#Q)r6^MF&#t8j3wGf zrf6~Uy&Cn+w#NE&&!Kmnk=Ih952O_IO4IV1UTm{%?i?@$|w&thv_9Ta&D%rG%oQ| z`{RYhV5X=T+!iE5rp8$nR0al}hHcJtDReF7F=8$bK7S1FDtmFCc7)TAofW=C<=89li&Y^%$rYtam6B6ZMK0T0a$={n>zwcXy!U!A07+TWlHl~a|IfMSo_p@O z=bn46?b^tUn%8E^FK4c~aNYqgTCQO+cu_sIBxtTC4}V=;S?&UFZpi9TglhE?LhG^% zMJKLZ&Q>@^U{TM-O*O#cWi5!Mr7s9ujJsD80-e07R4iQ2%hZ9Q$eEbO9t9nRDbnb4 zTWX!@d^fhvPHK%dNds79#!job(v3$@$pSh&GSAu;qWY#6cX%o_l4X3h*Xlb;gWryBNemZzqjOhtIrsoYDPg=`y zBi`aVM~cL!=^^kqYRPqX71!X6C^0^7^)De+sE~;Pnt|UIW&1Z!Za!E{3*qpwwFWD2 z(^P7Wh%fT#Jwr}Ih02b=-&_OrY3sYGG$Gj;q*(-(p{1OHUbAF#MUBMvnfs$H&4zKO z@bDXJ5xv62SRZ~wW1Fcuw4%1MS99rFyGDuAz(+F*rVXs3tUV}h48NGhiz&|^aq7&l zSxrE^H(7 z^!L;@E_P@UoWh)893 zf-6y1PU=>CW%6abwM2W*qpZ1O8B7ty^T9K)*z$T2`{}V^eyKhiQepZ1>I!*gd{0$8 zr@6FBEPg3{tdjAMW&D#F|CIRWnjSkxF|&PRqP{V;zA+om5pNWivO}wC24px`+pwhzN~NaR?8SZtG-Y97qKx zaw&r7X>*j{-$768d&cm-EuIsp;P?&|MH^QHWuH=ul03M+#_V`O*aV;8^A?r(7k6fN zHENo(offe2JtOm6u!vV?19Km09R@S0-j+O+`c{;yb;X)Ya`-X9cXQkrifN?~qW!4`96r zKg1P*p*1o^$3Zq#@bsNNT_@i8hT2;=?O75F4NG`8plZIS?t6lF?nZqN(%t-1h4P@V za%5D-l-fpNi+b#KW_%=o+`JyTlgXn6CZ&XScy^*hA1-4pO4g!&Hlt)=3N1(J(|XQ; z6opJm2-}g;HA~G&>9Q60we4h4N*AvFhNUQl_DbwaQP{MEIWtqTLeWl%Zbpy`t+0ql z6M$J?vbKWd&AF(K-2un7q|MIx)H7YhRw)V45{Z6t9(}tOQS4+3Y=iLB-XvMPSA(nf zNI37kx`4Dk)4FttggVW&nN6Sh04I0P$5WK|F4%R>un8tKmxs^4w1F;~Z-s0U%=d2m zp$Np2#dqBK>2v>zJd+Ey6U8qq+9wOW%fK64K(1^QIkr*crV&1~^}8o5F4#U6!L1(n za8b8HOz!O6%~4;nH{zZBrz0Y&w^|WzZ*tyEJ^i{q9rz~rD4WUE-Hj709g=JWix|nM z0Lqcn+Z)Ht*3qxCQ-QC6XzG+hoes@OdS=0~05hJuhRESWZkvYG-Awk4H?KkG`s~DT z2kD+jzpF+%>RSZCsyT_hH%lF&8z-;JJG881C^}#ExIzyK+3ysw=F_=qN@{!t4eGh~ zZb(Lp$|-;C*I;`Lhfo4c>4hER2Sfpe_{7_3`(_B6hK{e% z(KcmN&oMj%NDb*|v)<7~Y7@EyTUAv@UFJ; z=E{l&B^O1vd}T1(^WdF#AD9YY7L3$ zxrSB|NA6HqbXD#77hd}jD^mWoR1Z_h?%mw-a@SoVx8w2rYRB4vJq7J-uHhAD|0GRT zWx1{9D3LP=g%g1_nsIlP(o;iRB5T~T=8h6jlpk27ZlB1B3Nl_3J|D+duv1mUdg&Yh zj9;>+M)i5P+A*dHTMHy6IBNmcjRNf=)4)gc6GpC!&!wIAjA7W*Ub+Zi4IVFMlbnv_ z)ueL`XM^^%_u$I8hG+VU3iEAvYr%aCuBU?G&ImR_K~RNel8Ye&x(OgIEt~XYjg4bH zT-T>=-Nz(0lnVHCvW=pd(15w5Wt*CKS%}vpZg1Yqd8kIkN4%`m%P(0(b%Zokh>qh? z+dquA_p{lKkXK1yIE!~X#(U;tsdKE;flVA<7@}?dQfKkl8b0&U0V-da;_vtvf2Sre z14m!f_=}q0qNWfs2-S2}tL%W;-vYobb+FdO6{=4gajwxoA@x#+=nh|ho0<^0n%?rT z0r=R+IlfP?RswjuciCP+nDk<9&5*K~!JyaMteF~G4&@S7c=vq%jJp$brXF>dVNbx{ z3g8d1V4dpEK~UO&QqR;Ir1atlv$Y)pDSEJT>oq$yD1wumiK?j0Q|GWV_1dNR32-3q zcQwH$E-7_IQdG<_=rZummlmP<)z0-xNYjsX!MhN3uXu$;5QL+LE#op4rHnjHK0)vG)OxHek>ZhsAP^l)yB&aVR*rbY*W`#p($JY~Udf)2&92vc zWs1UN*Tf-cx;{*U8hOE}I~(TnDJ(I>A=!0{0HjOEGrO131z_jFWUEZ9}xoi$w>y*mk+?Oqt6z6|??$B>rl${UmODd4a7 zMl9-0*Ch|x|78Y4%qGj#i2@8|X!5<%MMA@KZ9DG-5p4)3&d-`X=Z6rn#UYHrGYXby0I& zoDjYlPjG{oB8J%IE-+m@No1qIc%CisxXZJ%$$y11hL{ zNLbdAMoe#;lai#UT_Ovjw=^7|#d~f~FVMeVg4^5-aTPsA=KRR6Ov@wxr!UT*Ad+>l zeFY!qf{nDq{zq}QV@T-Wgd`WB5aj<+j1o0s;8iRb#L%*Rq?f%a#Dbj}OB(4{HOOtS z4L}K`^I%kg;h>Wl5&R1p`QL%`@*jR;5UnO&K`o?feu0{f%5L;mrKZ6qUl8a=9e$DYu-=LxJk@`Xrw#lf^O zqnZThd7PeUlFXXH$8M6qw-VEWX&RHB^Xf{9V37;msR8&k)s}IiiLa4+O+`IGbCs0$ zOwXhyVGlpsjK)5lO;2u!(6#Gkjp0pgguZE~P2w#DtEOsdX2rBjr<*L3ge9`?iAx6n zcGoGBX-B3fZs(Fg=`Opq!f4vbn>tX?$ol@a7UP{zj}uQBlVjq|QCXdQ}y^ zU}DKyu@dMo#r33TpUYaqB34^`9R?5Bu9&OPY9yU(t$|PmB}6H8!z6WcC0-MZP56O$ z@pbXKhh3$URG*fQ_?@LLii!~R=IHkrmcuRTH0!+3;FKrFGCn5Ckty1akljd3k=NaG zsF4+LtacMq#fJ&I$(%ZlnXCF*dZfndv1$QJr%NwhUv_VKCJMxsyr>6PhPqd5)dS6p~>#+@eNn7L+P1@2we2hnAakXH4q+se~hDyM7F zvsqo<=Xir4R}kyL6E}#$?X*EhH8j;OCqRF*@6#|1U?~7oV7n(z)Ecu5=>pAhugp~K z`&kzCC>&rrhd;+)X#g-HXrmUL+O4?jwn^~vMT6hEpw}&~*taW4_;&P}%a<;B0tGen&HP)40>XNU{VT$-}9_WVP0SCr)Bx^ym96Q*I5j&dGGa* z9cxyFulc6(lTcvU%37&k(KqW-@H zgZG(sB$x%lWyPLkN%CsW++unO5SX#9dG^0;2}$Z%t3Z8JIgTR~ zqikJgBF*wg)Hxj<@>GGRV$;7XYIfQ*P#niAk-bpP0+}Xe7K?^8-!85ghOBi4~II z`nHPYJcEQO?cM>fN=pgsb!A5sv+BN?zji1f40wW+5k=e`dCy1(+%vRAcEk`bC5PBf z_GF?+7E?R6+`$!J3&E8OTb#LcZYc(I!MUR?5~*ZhnoD-8zRHHLj^V{v@rZpG0am^i z9iF6gfxi)0K1+M89^#9~({(+mxH55`$u2}hj`SpxjMi#drDlbMmPgMEGuuUG#WKm= zaMe7y<8mgOBi99G_AAm6i4=Mq$`x@j38pA7eTeryqiQGTr3i6c2?vwZ4BhiALnooG z!ir~}y3?IUHe-32gp&mPI$N>Dm+G9M(!REogB7-b4n;ZpPc40gflY#3MX`H=@5(Tl zOknb*+(tt0%hpIy&9{iS;v2>%4Rep*=PF$Hl``<|UH8{Ds4<3yD%UjWGQI4J_{BioHxnac%{Mf?Tlav+nwbN@!9{q&t2$lE z!ck>%2xwdD&~~}H+JJu1y?3Uwo}h*Hx@aV&-D$4@hnD)A7rgI*H?+GVU%GBx-aYTc zIdMxv8GtpWQlyKd^&xH|4lR~dz=qp&YNo-HZY}%sJ;VTB3M4z`2J=*R@sw`yCOu6#Y&L0=nI=m>^NVl31+KVfMtcspj6IAxVV0 zge2$qXhI+5Eiy>Hc|qe%8AG}@C{#OqP6R|MxE_6wR#|;CRaG;nLn@Jg9DMr2eLucd zBQwnkf`p736DzR5IK?*SQj)M;h@+GYg>oYp!hGvMC8_cZtC7j<*z&qH^?jUJ@MAIC z0-Z}2V2qDB*rLWm&zhsuXC_|gBy|%WM5bgXQW)lZlvkjOgB5_SJ&>^ZY^T9KK5fRs zQGQ4rA2e9#ycg(4?T*nF{Vg`9+Twk^QqD)M^N#tWsQfh|B_+&P6*X5)m=u<#Tnu5{T? z!9DUqpvSCcEty?5AWce{kbuH`^gNsj~>_u1f zGA(zUk56S$rkWc20HsJ~DVPkZwWF2va;In1!K;BDE3y76-=V;ZZ!e{I`7I@T+eoQ3 z-H4v!Y%VPyREQchAP_E-#-7K@Q_T@u^GB;-NSAAIlMFsZ?US%f;g#Du8{-n{mXcN+ zv09V>63R_kYp5MP5Nx04v-gVeVMExGE}^6i7DBl~>)RgkF6EK>l)h(_dY8!Rbfb*4 z3D3z!6i?h`wWA)uk|Vbn=q3qi^WiN4a!|9$r8o1WXJRYLe@IQE7UQT(q|1fC58qE- zWSWm3H@Cra!V1NS<&e8@o4W+~%*e*q6X&tCO{Uq{vXk?SMj9yq0b@F*ao;9Doc%1 z6D;4>q-guT7euu1%DubgPn6so&F&pZLE&iE&SR)w@{ zG(Ew^u?zMYij=Qn(9TuQ+&<2i^V+Ctg9oQLSgi8ry&rNnRsiG>azuyl<0{bD+!CSX z*lY{Y%7|X!x>s`qwlViwfZqsKDNk8{i8Z!TPw(_Ock+zSm6DC2x)BqK7uZ53>F%!p zKAu&j4Mb~PqZQ3ho;zjSNw6F63-fAQMN`_UnNdZ3Gfah9mIwu~Skn9IGWLj@tlU79 zKb<&)9DIdCt&a5M_8r+KK@OW7^C@*-5DjmK_{hel8qHZXfT?#x$YXUC@OFp5%X|EU z#SsE=cXh!rY9<4dws$?34Vudo`v=r zJSOmLM^1)Ak?$!wJw8pR$9R_YaeIR7-Bw$~_vzK7CsDOU`Pxl__j<^j>PRd^*GZzk zfHD&J;uRQ_ow6lTbouYYd%{)k$T>LJ?fX`H=27;{>+6}9*9%@*&s>3Vhr$clv*qBl z{JekElz$AIvDm)*?Z4M8^iJ;l2CrVporxt+FTovg z`Derh4+<4NCgi`c6TYrv=}7R>i~n{@@#88RJetBUqUdRlzIEciQIdazBz%CxJ%r)j zxbRd2^i2r+9>i%YYjWbHdwSr(qdM7#48)AQ{~$sBp@HH@1~zzLAp5vL(Zd3L9~B@g z{njXdf0O%nGPhr7YTudJcQ*6`OZkBv^o%|8{4LY#w%%+vatg>fPSf|R3=h8(hGX9`bGGl8Dcj8(MHI`Io3whlL9)9skZ3tsCtqb#YjhaO zr`hkiDY4D;C1;mwlSaedwh^wo1a#KM_1)#Z2a8Yl*1pY}Skls2!S{!10O>9}Cf3^2 zm=Ui#&zN~SwXr9?7f1>Il?q+CI0K9MDxU6n2f?z%h7|rWt!UxrXOMrMt-Et+gN?Df zc05sog88a0dM@DOF8r()oea?9Aol4)9DRO?PD{c(?r;rXB(hOUa$kUhxeC;_zk;G6 z_5z=;yd1vfn>o8T^LQ66yqz^~A1kr0SH=trjuAp)oEF05g%V_BXoW}cW-jcCS40rK48-Y03;uxEiN6o$)Nj};#rFQ4ydFMT(plgc|bgsr)ytpT4 zRRP>$aV$eOK=zSSz{k4r)D$#yTrfcir-%&;JUr-j@VO#H3(hy@%4QaqFox6S0ywh^ zR(sfCDmQ5}jes;fGhdk$Y%zH2>6IxBo?`#B`ls1Hqy8E8&#Hfx{gqJ-02hZ;Y)C~y zY~A4EkZ~I_E+G>(WI{qFZOEjA*v3|*wUuenL9oNlxXad!0uQjGD~gWZh z_h1sWW-g=O12T0L4-xD6{>eeKOm#i^52mM=Uc=8sKfi`eRsVTaUDp7bZX)*Zh=RRT z-3_%v$QP*R*cesONtF~@;Rm>TbntHniQ+j7dX2C)HoyYeWb@(Kt>w$vu+^M1#wVk1 zjf0^dI|*Ofu+v3L?KW@&7Ian#-y2>>ajm`*xC<$ptuTXLmo7>B-5{QiuS=MsgIy_! z%-PW;rYHzvB=HE;n8~awx{i<0b|fXSHx%)6%tFw9?S&-12H@BP-)cPeQ-WTpxZ@1h zC6emvvA+x6Bx`JiSDwh$CA27*4=POWY125F#(cv|>ns3jB&}F3g&rb!9c(pa*u6&b zs)f%5!}{V`ugUh&U&vGyOC31>U537*M=y-I_D$fMeC8`( zep5*|!}&$)!V9t57x^aSVT9Xp)5pei7#;{+3-H9gIp42)D#Xi0z*zK)vO-v2Hvn}2 zPXJ^QNr^Kz;v{RUqVHSy2ZOmIMEyyHcMofOHrdLm_& zKt>^#=M^$+tU1`ZxLWOXg7-wNB?Y7 zN2RD&vYatW^J8{0V3>#ur7DH@bK6~dL8PE)QItrGi=z14I3I({Sy6fiXq32dd$E%; zd$YjJfW(7hCM8_EJnk22jsA030dFOTI5`HvuFEgE zTkkLNrS3W&Pk0$JXP$mC%kg=y4!GX**fh8Unfw7}w8a#)VuMQ93 zu7tRD0&0d9x4kWr&qa6LyQtP2ntQyMYV~^WPF{_j)EjV+E{aalotKW(ofnD?JbcI= z1d$=}q(|zw-o`ResdeFEGS~&+d%bA-Da!>jKadSYa*++=lL3z%&%dPLjq_CXls#%#L&u+uC z!JZS8bNrUc!`eG>WF)1W{s?#+suxTf7hX?9|J?UM>;_)FP=n&nI$wea*Wrz4Uq9pOcAZgGiq zG+JzVYR!4Xex?h^+0b-RL?)P1-ME8}D9(%ihaRI8ruL6nY$b6nXTihZ{OhNhw@`4D zu@97tf92LGOlRoT%(=Fx=V$^|BvN~2a#8QJVy6?}=Hu+LZlml) z%WOL|qKHnAB0+F1yfAq-IFG1E0yT+$#?nCbH~$7EuGN+>_$i$#R%TMs9V}d4`Xwov z-!2v#AWvza-mzRm^lG+A2}|fK&hJ@&^q&vZRNV6F!pNhmV=+nEIM#J&<8=7}33*1g z!ll#05$3s+FC41^S)jp#7Pu~mK@`4oA=W%xy$%?-P^JLB-OD4%5;U$5g_Ip-9Kz1fq&9~nt6 zL@*EK0Up}1Cs(RMIg}%iT1}SauLpv+3lNlOZG>q<= zhZ+>m*2AZ_9y5r?z@C>ZeTA(hi@SL|c4~@*gPDsBigmbkAYvja_2}no#CEQ`RX*gY zifCn+qJY!#6)p?;)jKhJ*@b5VcJR){*zmhZn(q`N5gHd>xkNYDQ&K51)PR!u5ak}QRFf}}rb$R97{5;w@MMJj*OReK> zG7O;W1fH7Fe#~o>Ro2!sY0*ICiQuNIW3gEAyJ#VzIgpxDVmq!YdZ(%8@s86~qt-=f zi!?-3sI48O)C8Ogm`c8-253*$!)N9#kn~1b!J1l(i6l=ZUg$};>(9MSwCqLUc zw?Y6#dXe5vxayjU{H~cuZwkhzS8oHs_)6`?#zNuz&sKV07f`Ej4%1(hRIanrBTlX<;d5e6%xvvF(~N|sqOrHj1PQ(i!%?lfa3y@{6F z9o)*KVOCrvAjBTmlTvYU>7>gX`cmy@wu2(`a1)ZGAE%OL4`siSM%pO8Tobiz%dBo? z+vP*RJC587vQ~$)a~E25xzE=bX7Y~ zsfTg8pGXbr1=FAjCNL{-HG*jjAHOp0vyu~pP!bZw*F_VHTX z5jqmWYm}(TZWH?+O{#u}U2OD%FthD?d$CG&4Gjt=@{VljxQtEDRPi zfw`eL`b^`}C2RExiR>thXFjw-p|wkw@F=Mntr3%6$p=loQV=*(l(}A%vQkvbY+=e; zVT&3?p=0BPq0>d>j>Y+~33HT>UC7YWGxbZCrV6tbfTI8y`JhHVXgnV@l@F>FKwz{W ztf;l4BsxT$xkg9yb3{i=HYuu|lFykBiV7;7C;%j?3h;TK)95?f0cMt5jvc3+yD~Vo zA-=}6y8(#fQBc=-QKt*Xtq{LzMS+cCoGlD382U=V*iRR<$DOi?jjlYZ6;&A(1*)Q+ z$3kY2d9)Zk#*D8rm!H2zjy?)?yj-v%!=36r^-&D<0DEMQZ|Tl~7<1~8ePL8Ku)NfX)mCdwyDxM#&}k558egBqo`MI5 z(fKA8Oz%p;{I1Lv5xyd_SAZf#B(DG|#|n^gtjf1^hy&n9-@V(=49~e`(z~ToUCUp% z(?}Mi|>irG`g8Y`~dw~+@J6k(ATS! zp57_NtiB2+*m>!AvwLam(&(kd^Ob@qh!H_=mizTWnQP4kq~7@?VXs4Sx1eVUfZ0T% z@$rH=Gwl)NSDb!2E0K>;u_idb?|+lV$N{500idy_r6+e`$at^96Y*;Mw>9{JBAeB- z=Db}7|5Aq)SwRZ2IOw*hs76eurQQvn&{xnIJOoB-3{;QY*b$&uU45&fKVhtTqG;Xo zM>O|EU4PQ}8r`A|;)^H>Kq^;g$ZokCAhE-Sh~b1P%nrV@KB6h@UP}oJ zl|JulxSnok3!;jOR4{Xe5t`*7L#FbJX!<{cs;vs{3EFkoz ztZTM4KtcDlL=(vY!`l5O8L@>PzPan)`+H@~yMo~5ws(x(OEJ=LZxhe4^mMq!&Y$C> zz*>}A1J-;U*RfVlQ?C#{MnT8{~wit_wG;vHm3Y}Z+oomot5MO91 zmt5$|!m_*2i|7D!eR;JRc?2TmL~27qYB&y)CkYP7qhnT-CN?R zAe;pfzX?|SKxAzdmi#rRUzVGhnqPDf~YFzO-yFYP^$i-eMl>7mCAT!iT2i9xPHqhToa!QCtB1&TEdy`?&z_48GV?6rczaJ)H%h9AiCf>6MSu1OW% zO32eCF4O2Y`QBTf=eWh!1ujH5nPxs^Y)?y znc1AH*U_+DADfPbuU+^C+OmAT9c(H+7-KZG(OyQ5pa^tMgU(;D@@q@BLhcf;(I_T! z(*Y6I)62`gFizOolU3;KDw2)G-Wom#IDaZMPEQvYB5zKiNEH4=msxK_ga+C)Sk=$< z%+Oc7Cmr%mjh|!?En~~?_z69bh$bd!DC4yNRIqgm3#^Z7^4L4C@+PT$%}>f<(_g-N zr(V(ErQhH6ionP!)8_~nl7)~yYf{>A``xylAXI?l6?|+Be(4A11?-(Kx(_fb@H;g@ z9{8N-tkS#8FqK+S)0{wMI5Yr+KZ~$6H7LG?O2X$$sd+pVNFUsL%>>6iFns1Ez#{>v z;9R4D&np4kR_PwPJi={Wj1s|erh}fJ%_j!*5Oy*!<7GB-JbA`wsb<@0D&1vUao#HG z!`uZk8auyWSl|s5-RC_NCIDy(Mq>1lWfXhUBLEG(OW+5HG{MtrQ`=d%k@DZDofmum z!H&?W3#Gw*Kv^dF>=iG$n&IgnP-uT&0H9| z4hr?imfO=Z$DM)4aFE~X)SvNH97!|5QbjM126;A!qGqTwG6#mW~VaTmc}FN*gxn0trJHNXYT*V=k%K1Z8dm zl?qV9Aa|-y?G!OYQ_XLk)JJh}kEU0z_*|RE5Z{INo{?6CZo<3M$88!CLh=TH3YMa1 zHBM=t3M39u|xXRn5B{>$&6M>L?VGgFvTABdWJ+nx~B~fs5ipW5QMv*uo;&ZEJ zbUk~8NN}3Scu(Hb%8O?xx?Knj?(F4Xl5pah7wA=T!{LItIOVvD7BH|T`*JG9|1pC%GpjE z4crw+7S>MFL}a5*HlXJHV4U;i&=O2femMpOSKfe8%b7*AboV&?BsD)q3w|!C1Agao zEJlqupG#v!#GWVr*eJy&VgQtT<{P$vt37L?)Z45e=Rh1q+;z*YzD7k`E@9k*MSOvl zsBS_xYBT(vyesWiSzBDRl36evQ!`f}WC>i05Y{z`X`5wZc8{2IrfPl; zQq~~c%wB}>%O--~x@kga-IO6dAwTCSL%KDy0&!(?$h>Ao&8Og7nk&i~o9mFW3*VF; zKJP%R%l}kZ!eC3=xnq%9z6z<#-g(=8Eb|ppF=pEnkkjmJdEw@<<5YSBYFUPyU1>pT zOG=?W^O3WVDhw?{8Tp(e#yq$LAuVeAh&c=2tMJz~W}hE^4szDOZ65POPeQ*Vf@l-^ z`ndG*urWu@QyC4Yu}i73jR@DP)RzcyFqEjZDFxKN?KSM@wla*P+4?yA9j4iH22x?UJ?M?u zdc>5r9fa{VgJo(N0;PoXJ5v~2981FY^?yB2Xc+-;5<;RHxtjpGh^FNT zgt>`a7L;mH$YtY~7nHxk4qwwAe;S zJnrgyoN7#{#heaPG$|yeurZ#{Th9V2D}lm+gK1kb>;L9tA>~V`YVATqVN6%r64HZz z*oDgkFq~_3YBq;GVMBW~d&1mYdYxu=lRE9_3(sN>Pbpm$hNb7VrbRifNS>=SBXQ^u zumGaL2*T^InwZ^Pq6HnQ8T>ovy`eBqUNRbwz+RNLUolHG2sH__D-eJlK(>P^GPys# z0<~5N*fjz*4oDTs>p++e$K!Sgw10lzUNhqm2d&ZYd%}BRS5oWvqzc?MuoJ~NmP%@* zf=K6<2}V%U^k#AuwD3@IzO&ThQv^fg3(UhOExw+m)y0c@>=Z%13GP&KE)wZjp|W_b zG6zGlqf_s=9ewjyaf;IfwI$&_%+qHGZ(aqM<2NF@e@<{93ff=LiX)nP!6RpVQy=c1 z`h{SgnTHp=b#{SfbgDDu5kL1lgrE23i8-wOM9PC>vSQcq1))NbS*F!?f!YRp0^!%r z5`H521n7M*8+(pOo~AHIu-yv;A*4v$HkW@6!q3PYgLQTCZcLYi~g{`C-#y6kV zmjAJh^Bf~MUxQ!7REB4hW@tj#dw2Qgsn#I>9bg!8kLK{ksXfm0(8eik|979IeSqb$ zKjQBJ=4Bp7lA7_j2MrN9WAk1>!Z|4#bKnK8C&u zu0&RP^Pn5kGsN&z2@cAgW4MPckNBZH#*V(2gW1?Dbn^Mx&ntsD;$qJcjZsSEsGC>Y zbW!Sa($X%`aUCbW3^T6uoLewY>uQryF!T%7sw3GvZP|$=G|t$|mRlz(MLQ;+^5)?3 zk&85r*;Sxu{LS&=w64{>uT#7#EMxla%CJ4_Q@5iZnD@M8o^|yPM)}cxWq4yWUz~== zc+um}!kUX}dqGAr3HHLLXg;#c!Bk$5v24(KuDBGgvqAf|UIi``*Hg3pFD}xwE(7o! zi5sEC_N;6Kj{*SQ6vQnVvkTm4X3QhYaO?K5Okng`!m_X^SjrPdw~GnI@DM8jNhL&) zEW3wl5^H>g01PbePPdJP?c?qcsAkV8VRw{WHG?W9ass1y0(c8T(rn0}hVaD54{Nc| zhxb=mb~8UYFA2MUN!Wa|o#AF4)E(Y&A;ieab%3-nWOVV8De+K^Ch>}Fg1QdrcQ~k< z_0Mu;`F)wngld$%M=0T>UP+G1sAP;A?QcFK*^xO}gO;7;mCb9smN1noQz)lhftuCN zEyk^NnK-ntWi44x%7oixS(#9-<(J$L8mH|=snJ0|6-4tFEZ=Ol<9-h1Elq+CtYo`+ zU0u=nxP#?_IN)YqTejFKfnD}XgKa`mL^Exr*{Q=qtK%N7#arz}p5cY8YEPGigKErxw6+4*wYx@pNsF4h883PS&mO^!A!;7IPNS$P zQR>tYk;hq0vpXW`m@RGYGSSTyXw#GM?;8CZfxmJ1<<>q4JLpmPR{_^cKoidZwRL?& zd5(>)uM~ro-i&vm`%e30x__| zt;p4NMq_p~h!EoFnVoea62jN*W{F5by=oG{TV)K-z^Fy*N|$yExHs(qq?nK({8Ex@ zKWS%M3U0HfZdX;7{$j|gED1`Cs)Q-AnKBc>Zqw}KF}nzy+&uK)c{iGm=-3yI_22~> z3!IS+*(r3m#0Os@{G0RSvqW2Vb2#%{k@Z__8Pxun?bpeL^R>&fZ}IJ7(h=&jzo#f| zZ_|p+wI$GZo;M^V{^;iG8wHok3FGl#NNa8X)<3Hx1PLRq&{t`Ax>jV?5ZPXx2qX*H z{8hI{MA#iyl!b_uh0*52gANg371HU!0yB!bOpKV)`k(m{p)%3b6{16Bv+Qv^Pny*8 z6*qn}jpg+Mc_|f!_Jp3g($h?Bsn^A#WnSw|z4fr{%?=j$VxOSHpJc31)+MrZHox{> z6>iR7uTZ@@8iM zBV9`LCZUo#Tyy%))vUB2%#p<*sPpd^t*^RrX9e$!XIF`Wy8acfrX5eNpr=W06qT1T z>%XK8s1fl@O{Y)iLPRVJgXW0s6U2|Jcp8bO6PdTDLrHG?pbgUwqv+Qp#Vra!;cAbA z{K{%1!o71DU5l0~l#VxDlP_|==bBc-n)>&OcQDIAUE$Qei(1z<+dsD_$sRx4TaV4+ zW@>g&Wd^&q!Bl|WoDK;$6HGn0!Kuv0DzVY?E(gDWXg$wIyGj=Q&BaD5(s4+Ap?DJY z+0OGS)Fe{s$VqqzZ_D_^-H_7o>~EtwpyWf@)54}@Ys$tkJLX6>U4C0p7KRB@M-0X6 z1}hI$WT|-*<1nabq(c@QYFJi?tjI1u#M|5 zL;*bA77$DFx1d;i!xH%{U4))oVpxSF*=0yg#_FHnobs`sdt*otpygE?q7LwmA}gBjEjK^XxbE+s}q?RA2q*N%Pp4OuF) zSvPSbBwJ|F>}ea7y^H`{@(XdesG5%~LRe~8Mp9JHf=~fqdDm|hugiB{?0h2WqXi<; zRg&-FFou$@5do-@*2nq4dpo0n8C0;EkLVzGX)@I9Fu93$kq8`sZTB3J+=wJ>4bo2F zHk-*00l3y=(mLtrb&>M7%^bCsrEkb7jF}G^bMyD^HWRMuz7Y1~289Su)0SWiwppY0 z--Ma*e6v9u{+ps4eu$rc5`2@e@tA{ zIN&HgjFE~+l;@H;G3qJFuY2w#jS7^%Bez|Vkn_Pf8#V(4XB|)Ev!ST zDVp%HfqliKvq&xQ>)bVt+;07Tz1UDd`yRBm)xOGt`aK zIVnTCSkFRbmag;uBK65!>{CSZHU>EY-06$FT*$6HQ2>j4OIWXjq4OFH`=^BA?1~iX zh-Ft$7q4_RdHdZoz9zF<>A3XpsPvF2EgrHprgsIw$f&r0 z$x27a9d3P!N-?LGtcJ5Aa&4m;-9@NUCT^QgD;RdLtyx&|$ZbBClJi(}3Vm{MDAN<@ z|AUHWRUveIeqbKcL+da+grIp?@u)4r5*8E?f%{0YYHvsMOoOyH{`l=7zOpYm+}UAf z8qB-c%T(HBqguO&Sgd^RPXl*^%S(LE8@$Bpa{ll)ze7JH%$EbZqu;z%CC15A6jgZx zwjyg#LT3t1O1b8(&Ksiw*V3X^vdXK=u~EApw~{PA@a99$td4>XWmYk2?wqpTEshH|0gn z>0TC<{Mvj3WoC(gAA+DK4o2=fhsrl6N8V!$+>Mh!x>nQ^ZqY_WR z>iBJL<+3nEe|vO&Bg&}bnP#Bslx7&F*Q5mwTYv$*`Q|&1d_@HRokl|)!ncEh#mnG( z$oI}8Uol2xQ1KDuQ~UCX#Ki{7Ke=0nRnakxlQCNDHaD+~RJ3>kIBB`6zMGafCvr+|Ap(=## zxU<}kE7d6hW_RUu&2;@gRU+A?X~d!sCYFwn6~oN2Wcdy$^QYn#y=z${n(-lQ9vz_# zb-gbnkHX#v?+$9~`lUOZ!9>&p$jS$c4!GPsD|f&bE?ho#ho>06UWi{79mnj>+|l`< zPj9Xn*111!nzH#e>;L+=$Es-~`P{TFuGq$^U@ko63QsDXN~GT*{>9bgid|{*1ghU; z!?MmBR-EIh+@)!%$2tkE4W;!z^Y@E7KXv!53<=-Wbs83oUCL(scy;)H-&}_i;iUYF ze8rNwqRx%}t#r<;W@Y+%t&BN?bH-iI3Z<1*;Y?!dYgo|?`gGuVpVp-Tzp87{C+@CR zl{mTy8P@JZ9H?jQly>a|-B%>ZG?61CMavb!dfB#4cd44gX+9*z31rH~mlc{LD|gXP zvk&<5E_2-rMx+nS^6lRhPUg+ku`8V%UPZae@waD~#nc%;hyqBuqY2lWSDw70KhT zJ)y+`C-CRtsLBFM3RE{DUjpERE-Ru7cSG5AI`x3${IqUo~h@9O5HPA#{Hh=+R%6}mFJkryd^3_!eqH{!0_txtaK zE(T`hKLB912r};O`)0uT)lW!)E0!to+4IOUFFw0gC)UrMcQgxukrs~f4{r!`<;#Lu z4ZN(GvK@{!lgGt1TA%x^eoluj5jI3GnCKkWD@J zad&6Q%*`W-s(aO3CV_@uhU3~DGqDK<;A3x3=wu>ym$cKmDr-vgVc}usa@ZKH2Zw0S$1l=Xj%ke8a`FX0wM6M|EvL0ndN_ zZYYc7bp;gFnX6n8)}tS{2ZR48Pl=EL>xIDjAcr|XWaMTKbG(0v{e%%M!G}VLo5!UR zSEyHW+;v|Jy({kW;V_4mG>;qVgBX{Uz~SH>lY03a+v+sl_%HHz`Ziw8=jm1l0@i5; zG9UJYaW-E111P)053RuPtk2ql$&sHv{6rrTB{|* zhLxjvsSLSh-tdI=I}vUuT*AfYzkhcIN!f7!05^ZxLZ#~c8{Fr5>E25wEBQ4K^%Gl} zOT~u5LNj1R{m+YP^CB$(;@-SIu37gEYGT4Ick_wYSYHv@5t{t;{%Buj!f^#G@>c@j z<0>?-bKI~Jh$8^JV&_dssl@<)1$oMBY_6&$HL85v%okDlY#FZY#Y4>4`L(PDy)P8X zL)|}f$;TFLaFNwXjLJ|unHsVZ7++@L)&Vt>f!8)QuQ~Lbxd2<_MRU=dfmR_9M*#y_ ze|K8+Y>ydp^Z$5zywyg$qwXnU>h7wHiBiL?kcjmRmC`H{)v41&l9 zRS7^bKWo2-^Ti%Dx*qIz9F29{ZFb4co(66?*Aamm;kZ75#_M3~i;c_)Fy_I)*GUzHHG{*_M1+nnMpR-Aq&YDz~fV zmA28?kBLIKj-1n6Vz{{7i1O9QtBDYAug^0ITk@K-Z*?+58Si{=pg$v4O#L##ws)!S zBKn-G`|zCX-|GcOdH$syb7anBH=`S*o^$qj`jwuwCg3y7K&(#tC2Umh9m=_}&FLZ) zNk+rM^4hCT>%f_<2q&^m<4BsImP+naGV>-Xx-7P$n3Y@SjSu=Hq)faTQk7jK)a;+gVgtCtUdyh|NSuTec++%0kD_<(AUiXh3p_PT9QIL0MaDF?; zt1LHtsoMAgc)y&V&)LJSL*5*4=AZmS59R?<>h-F(bt`o?KF;oU z=*bro{Ii|B7I6`$h8FL#SLl{xkJ2_z+t!;Mk(?uSGuB_bs5+Eo3POQGQaELBp;u{p zmf0%G;UvpyC^}S%I0VDGN-U;tdM|8QRzaz>TSb&25PUSNf8`94T1M;zhyJ~ zo-JT&%m;nxP=VNQ{kK&dRCG)h9*?B~RuygMveId#eTi`!w(z>DFHO-qTdAxj<$z@< zqH%a>+gE44ldgz)$WQI7YMCoa2R5>%k-v#{FPD1EjW6Cw*~RZ{o>AWTK9(D_qKjot z<-*+wii}ei3-#B0Ai52nrd=UIbk(RNcXP(ZvbT-6WlrRG@BPgq;HpK$&7)Ll{a1Z? z$|<9k##G5eH3zf0Mau8^lnsY~tpH|2^>}RFWUaGg-#lp0AS|b=-dXaITn<1 z$}7WfiEBr`m3V$~)#zHSyX3!NUr*o@yf6Z2N=md>BkC#rv&^QC_W!L}5jhFXg9c@

zVg34_E(Qt|;Q{yCEnX?Vs!Fhw-vNU~@6H(h6GG89J`D1=hpOgXBnQr4wl?cuyJ*yA zxni1c`A-cxtqKp2zkH#G8&z3K5gXLNYu1inwlrSqV&iK^_fHSgdCD+ip>%>JY+t4QO4Pvo|aBP`nJBf)jJr34sq~SSzN#Eu%)ZRZ9?CP6JhctK5YzHOnaOHR34_q&__<_^s@Z@vNZ8=3BgpQupKu%2$ib+~q6qm8J7rk#Koa z?I>T3M)kCu%>X^d(OFtV|9k;_=}>s1KBU-VkfP2T^U7V@5gEi4q(hH^VZ+_|&YkB7RGIJ>`={Stkg2|dLdmH6HROWw7!8-MiEH zduwRFH6qjKM|@*DxmU!Fu$EpwrMK`Fv3YFKV?_EYc|Lm5W4_%h1%aaIL9RD@lIOi7 z@UT8{kxhdyUuoP0<4j<9d3T4lRLp}8!oeG=2N&X!NP&Z5?(8@G<6GhLch z`szsln?nqnP^!wO#LpS0aeiOxHfWVlr&8FX%?|qN>kh21iVj{AM?9#N2+u>}KO6mI?jfCxzm@Y(ld!EI%q$ zHjd}DnGMFUJ-E`orq>c%&#Sx*4i_?BRWF-F)=WRAual%ahRT<-2L}F$kbN_vZ_8W8 ze+}*_*VjvTo1;iqEe{d=PGb3=lv)hvFz5q}E z!xR@xDDJ|3`SAIqz~^OAW%biuH^$yA%x^EVsok2}Uzb9SC5z6`PR=36mV-~KoPWN5 zt(&VOlARRnm9qdjCQ=)mdRgFXX7JQnZ+MDTBwQV%#>66bQQI1Pvb7?-5igd+%>(3o>*LWGSc>Z{Pv+Qb zWCH;5yQ2OZ*BfIfg2kmZk7coL-qejs-FamPy7|0&m$V2^lY%_?-C@(PQ5b6R#jIuw z+Yo-r@*M6}9X-5knnX@_xP1T45kuc>=a)guppJtXKP9fan74bfJ;V?;R;}i`-Ha;I zs3?L^_5|Fv@S$vKTgUV%i%oZ)r4AbW09Wm9di-R5;^ud-Z5kyk8R5%owb_Pz7`~>v z>T@~|hAYF85o6uE!*H|rHR_Y@5$HwheNPzOtF{Pg6#DRMCNCwCxJNL@vS9)8ip(0D z^Wc2I8KrVlgt6!q6n#DH-WbgBD0^HS=QFcQ9v#S=ws#8iIg_O~e*1(~oa&gehtU3Y zG$l7|(I2~ZZ^l|u+Kj6Zsv(SkPT=gZq)N@PZr^h2MkZd0%+t8zHD+ugIyBW&e5cCp zPBpSp{u(i%scn^0PAO`)E3>GD{%wOID_Do@gV4;}K5ld1=F&YOc9`F0Fvbk+8{Ssh zH#}I{YwqXI_I<9HjO`_!chUAQo^C-1Gcd;Ll)*diwH~1Li;pAQNpx$AK*X ziugWu9@x4YI`F-1>N{}X9`Jwve&;{1Z7+oUV7ni3;QoC8lKTe2umjs4gwO{Dv!MqD z9)j@q59PxT3_c7o`*#$@92j~8;(q#p;Ke4NS{DGa1LW-li zH%f6}*JF_8#QQc*b6__j!SBPE?=1n;TczQI#^-<;P5|n!64ZwifcmOHeK-NMShGMM zP7vsS?g4!`L7@Lt0QBJmfo?KDA5IYH1391%CkXWS6##uWL7@LsA<%~t1bVp-(1#NQ z`s00pKAa%XM>hcaaDqUe*%0W%2?G7uI{)PY;^$3pil5Y?to?F6@Bf z@PQI9Ht6Ct>Hw`(xA_YtAKbMKd$ViX5V~<;+eXXC;J!UK2FYa?Ov>`c_g(d^(w>_W z+vPhrq#*zg{sj<1fp7d3RS%1wv89&9*{K@>cV{D zR$y#_!Voz4VbHvJA2+L2lBCoec0ud_)womQx&9qP&W&jvu&(#{sReqJ+ClQo_e05h zGA*YilmSEQFn$Jx#E)SAc1bXoq6hf{sI)?3upf|M|1K?oWQUxNP`rN1O0ICV4@CktX6@EQmA z-%s`J-%c%|>9QcxXi%mN`hSPmjRR&Ies)p6AK5SS_4fVH{MpjL4)lU^Vave&?e= zLxtSYPYv~9jsDJ1U%qJn&<0G=fuRjKqVmuk*r5*%ZH5tAwNe<{6&^4c|DwUA{tsz(qK59ttS)$RnZK!i0|)@;A>b_ugU(LBp<$J&`M1 zc$j>SI*KauL~16Kr?1w${<;_YHHrP2jr|(UEBd|hh5Iq(@F#HH_yny2`**?ev7e~f zb!b&U2@aSc=kzE6%<7?%<>POB7Moy+5cP+hy9j!_tbafG_Ycube)BdE(;ZCu$<0*h z{k%_jKf>)7fd|6x=e5R`jLa{}_jB_775RQazP~2lFEc%Y0(NcZ{JR{nJjlfIpc2c2 zl4L(Y>ZL)U0CrdN`u^=h9KbD|-Rl>=y@|wYUzK?AgD!IZI zWQ+TK#zQVl`DMd+p(*w%e(W{EV8QBgTUe*t149x(wccjD-@>cGn?Jz7H-9j|OWK=1 zfZ(@`fcIy3GQM>mO~&`T!E!v$`?3MUL%B4&h5|1WcU%gQtt#`u!u72kb53j-T53KJr>VZEuPBH24ZCf{W!3!sC`a@q_F^gd73^ z64zVrSHie+%fJ>pnFnYx56Gk$05)O(D!VBdadSq#N9Fs6GFFHp)c(IFfx^%57~Q@s zVul`t_Atjc8MkpczWHlB*IwVhg@FSB;JEz-jKap2w(NpP2)YT>?e+c41km@e_kBNb zS2rIkk^E!NTN4AG1Buwpomv1U+_^=gw+IKgZwvFy!UWv>3e9wg_zJOx@WIAwZ8w+X z`x15OB`M^kEi|QU#nda}8sH;2_E8T0-O1cBre^LKUC8XRe}VkSC#sur9j4zSQvUn7 zVeeNjv9R!we!u>Hffpt~Q1XcVCcu9u0ffuO(GbV|6ue84ACTnym1zs{{QZ6TCi4Bd zd}R{fT;uOs=LIotMi_dXDab=5K?Dr@j-t-LgH`J0XEEw~7G0f-xuso%Io2zvhrxg~ zelRwmB&^`AU!kh>JABKKgpQd!8@Qh*D}0AlH zHRMk<xG)>MtbW?LXHXCp6^yn(}khuvcs^ZoM)nB$8Tp zlbXq_1V`_nnZj<_dEa`4Nuk+AU&irUU)S|>_|{?G_3i=}P4g|t!$Sg|^jl@myp;pD zlJ7nVypIF#Bj5cJcs~c;&va7)2RLwmd_xjA#DPQP+a`hAIB*;JwoBl44%|+@K?xk> zz(MlukiZ=rxPyETNZIU6;nQF9!1<5i8i@v21Kc$G%yk!>%tkR$U4h5zrE>?d56ObH#g7X+1-&Mz-;yeb&?LUX9MZ_S?qvLtX6%&w?BkZwZshjosEvRq7z#e(!C@hl zWlI-aMs0QNq{gX_n!KOcGb=lQl}5O@TVKUUS%onG@O?j(vEY|I{MI)m$DUhX!vyye z*r{1xfM)GwR{Br&4Zrbi{5}G^p9g#o!`KUe&-)mPE^Np{{%-N zES)&`KT+&{{ekVg=p7`6ZTR+YFb*nX!mRWz%ah%{E*uukhnr`3#$&wjQsCnK!|MaU zSrYbXmUYUqE(QGt#r?*Rj0)7bW5}z2sAMMtN~Qi%X6;wx%hi8{7V7;Xmb$s_h6mf> z1{{66gj3|&e^XlVoBK#W_WFKw4!`l8E$rOkx!)(SR{yTuGCmrxcPL*#Hq#c`i@Gv~ zf)WW7+N7_LkA80wLqV+lf_C~g67*NM4(vx+z#wfIUVmITz#s7U^-=jw$ajW!eGiG3 zcNB=I?0=S{;k%zPp5`omKhspls5+1x_{@q#kz-UHugEUp%fbzRnf;$(7R|oy6 z;%|z-DXY&P$(r#;%nc9EN~=&_@cMdb_|r@3_}mV{Q@{_%J;d(EpkQ&%a-E3Zv%I2F zLPmZ}Hz>!ipAoKc{V!z~s|dILU7X5C_}BoybRt{fmGIMNc1cArk$9Q-EV0)Q4Y35{ zGtUkm6qxi_fIMp_UXLrF??TD?Km82}e}yss^;c-npBIMs)8FG6CoUA5f{W{*tO&1z zwpE}0hSvA#Z^!^rs)dpSki&K2pK#co+n-R!%fe^hewq2}+n->5`}QYnPyPwDFw$Kl z6^u0F_G9AEDsRkjLvPF}&nYAQ=`Re>e#Ue3)bR`I_?$YvBAN923-T36e)@9)$!BFO zt>bm&diUJEF(ksNM`VN^K{1vDK!4zu`!jswqU@O20c;8*F7B#ldEuMg&npHyC)81>1{hr{fbEa$7dGwn=X5bBafUZm zcs$=&5dgojqWj7>-q00NT-<-8FVJrK;+`B&4RHOC)rDr=0#8F)IRBE5H2zX1(bFX|I2|tKJ$Tp`9IbF==g=-OGRr?YDk;?Blhc{pHDze)YBg?>Argum0)({j1OZ-hcbb z_6KT@{hvp^3C(~8qRvy+<-A3)&h7FLXa9O685ck?o7g{>G?482DG@GjIi{Bjjfl2K0l z_oQ(dpELlLKxw}pc!@l7o)R5q*u}y6inMt3R>HtFNQS!5&xRGV>Ry)=+fcO(FJQ4< zK5P_cdD6J6zE7I_uT$`|o9{pcTrWYx&X`3HvQ$oDF1+1xj+pFy)B(Qm2aYeq2zEr< zEP`P8edxb$0DrdP&!Az%H#h(5@Ivcx(fLN5$Gn+@r>SvcW_UYE{~I0RxZ<}t_0s{_;(6&oP=7@>hL)Hod5(m0WHUWC!xMss^d7g z<|ytMq@06L%yA4tFvW3jO+rWo-1x6Tt*B7hQ&i6k)iMVuPr=^|q&WsL=sp4ePJ#Ov z{2PN5+^z}8KL_6m!QdqPO~T)CYRfeBaDv*7?K%nnjzicKg-t*?b5O%c$T0_@Gmrz@ zf^jFnjjl0jKbCq5Tyu~UQyhc8IS9e>&^1XtI7RKov{O*R7?d$Vxld6^#{`}yp@b9g z$K_-1xo0!f=TU0g2}m_fWg`?Os5SWS7=_LVye6oIQ}oLge%k3 zLmVsY(+R>EER)+eM=%_tJlrQ7t2rv=6qIoDcklLA{f{ap*9dacVw(Wrg_^!~!p0i3 zqz=9@DiewB82n99ctm(JN+IKrhJ8~+B4-ItD-<#bC15JF6c7g?=Z&H%&ERc$HdrKih5bv7u_w;2 zR+~xf8M(t zovqE(t7Bu6abv78Rhx;%p^(OS6+Tn7+U(41WomS?J~~#7qRFYs=tN_p)~Jn6k55F= z_-u7{yxN$anH+0O*JsD3rlz3a$?;lkY<4=Hu8+m_Mm$=LYL!~O)|hQfSEk1%DwC6= z@n|$%t;|*`vy;{7sj2B|b)qpfQLR;H;<3tDWqf9|QLofz>l0H^eGCeQpUNaOV{~?W zc5I?ni=)Q$L~UYbsuDLEQ)5xJF$GN-o2|t4(P(^PG_F*}tMC&~Mbq_h@Wha91{yv+ zIx$(RO&b#xjOT}NJjX_#n!DOb>Sv=?oUTN*IDIkcT|O0Gqfy-gW4LXx)>(-M+nQi$ z*ZoUTcRB9uTjpeYrVL>{!2j>P+rnrMwFQz9e?UVoOV{bwRo}Dh0t{Ia%Z(! zKNc^p#LZ@0Ki=tfp^WC*R;X@pAx_h1Ii9a?h4Quffv%KbYyXhcz7ltPNt}*o73qj3 zO>cY>@arO`TLNrNpD4d`7zKkH%}$QaOihlCHf9=AQ}vnIvC1@*Ha;^s+KB73wK4c_ zvNl$$H5!evN@E=GE^5rc*hQ0o6xGVq)I{84>#7eDFnVOuf)@LTB z$Hwcm=~=+u@%qF}r8+Y{9!-x&W7S#%#(j38R+*|zRO6|M`sBp;G6vV= zcr}`xh6Yw=Ca0omHHxdV)rryCEHrj>bb7QlH4f8eY^+|d88c8aTZ#SsRKd9aT^jd^ zr{?Q%8|Q!Ay@xR`K)F3Qm}jE)@+zbrIo0f3gJuj+GY%k0S=#b}7rW8Q*-rc9^;*1w zL}%%8w{tBm5s@ou>f_kd%2d9oK;#ypUhOiV%e79oo`ww_w1~gy8FK#Z0jiV(ROg2X zd5pgPL#*!sf25C=%=GbQ)J;~?^6^ePU2XQD>L?>W=c+#kK+RS*bMpF1Cymo`?{Zvjb!u1QdbvX>%Sk)! zMeSPrL^%$RRA0~O%fLvCZCRgM0Q5V1g^{40B{(_N*!^g1; z?Nw@cr%~=fs`84>jeTjySZD+&3;l=AUQOyT!3S3r#N29pIl7v3x+6dG4P;9Equxq8 z#qG#93R?Wrv|XHd>S7wZZP$yJ<8D0XrcS=055E{6>c-{ENgd{pVEzb96ztc3{LYbp z?Na33RR7~TIzKk;ey_Rzfm4?ETKQfp-)rShb}Qd&;7@!5e>@QJ$D@_+HSoQ0ey@R> z9_P%@zLI&?7&_@0oNvSCGwH?k(%neWHWG9d39R}__N;G%CS`tB`vH7>?5X+IN;7W3 zmUpoiwd+y0ZV#~Vz@yh)MIl}Rzz@!&@QNfyNjvE!Q8W2@67I1qsJS-sY{`r-uBE-W z<(-i(bvn&-WU<%nw3nM}IGA;fJhqxN>v4Dc#KeTJ9&b2-^uGM-FqLatwlpL zSTgs`Lr;ylQ~>KI3Arbp5)>9u9k=#8Vv7y6UD1z&*CxCh=cS)xCG+(0DD5@lk>j1#N~aAtk&c{5 zY6v`-^KCUwftE7kjv5e)@Q4wcRT}U4D%mpL(J! zC18*^KXsS5vvIHJ=UqD&^Kj?xf7XBHos-Hf&_M$HAJuxRNG6B`JIV6Zq>JI@M9C86 zB9hMOSa2=!G}p%0N@llf;zgY4(895?(b1nqKqmH-JUW8NM$BE{_GUN@@6W$f?B-)7wz%v%4&d|QrCTV|e` zr=y1+j>}wkc@=?cX?+^d%CJ#S+aZH0n*jfEiwGFW{`vR-4|i&Daur3L7y@nY;tJkr zZ*Wfdy?0IsyJarTwtD@u7M6Gj!!52wxGq5RBJ658;^U7iTqZC8wFr+edY2U!6};Yd4_vAot1OsXH+$ zA1#@w*YubcCPfWZhuX`zaz<<-SMuG@c~;qZi08-MFkeMKC*J|K)tjuJESVRUI_0a7 zuYpTEDi3tp^#o`66J;i{uy8n(KB-nn)ye*Ex= zSIH|S^T~I(lE-m{AeIknf(jmTKv{@@*u!5`O`1t>4Ugp~VTpeM#yF}rj6&Za<{X(e3>#b60+XMrGrj%O*CGcNKg0wY~TABlu$l;r~B--vei5Rp$Tx znYs79Gk4y(_q~7vzIV7+AqPR7QB=mjphU3-MFj;z1qEda6%`c>YVN=J2e#T`VM#$j z3!4~hTDq&QmbSWSWl5ncB?To(o3>Cu`tjE+X+R)NgLmJXwjKyKvIt#W!|ddGq4=QC~^N&!0Q* z#M~^kU5c0M4daZ(oeOpM`1;&Utaf?b{;C`2&xJIPA*HYWM zX@=U`R}Feh?$!mJS1tJejRD`$bE0exylDR7mTNgK*GA$p>fMKr%)n_Fk(VCoLUsMs zV>l*vH3^*>79hHaP2RS`3+FFdNWwKQcjZzuebO=s2Vh1iwqtB78)d5oG>{Lk(YE!j zDDxrQG`zrdo7&a!wl(r?9AFRTfKX1htrPwnM+XOXkRto5?NfheI`xp(nQyhc0aQ+gqe+z%l`mdMiUp}$t+E!4F)J5~Jy7@**MH{sgZ6}{{hMMP^-_dy; zwGY?QILaJWlmY)$a~Dp(p4TR#ex6}lgR6c{n|~t>Yp&%14rkuDwl>MU8Q00NmT5P3 z-a=aceb>*Me@N{9GTXcVC;9Rh5rY47QDH^SSAk;2h%auVp2P20=c;fk2kDq?#7~WGZlX|(Es6kwagL#&t zb8n*V1i849ak#r_Ko{#T>+OGYyL*_v*k449jKA}bqO{M%tnOvf(-hpn zy|(ivS-sU@6*CL1V{+Htbk+4YF6_K=49~~0-Gr0nx~4I?_uagZd(jiFn}74-8|N;J z{OZm0>pwjIx(QdFe)`-~uR8U#w)RuT&Tk#p-gUb@ea6TBb1^x4;oNKfqLHX&A8)c! z)b;1zmY;2BteRL*c+iP?ZY-Tj$`9D$_f50v*KvzEMRcuqW5FW&%h$xxg@?%W< zFcdMl*3Q@zN^yi6%UC)jBy6FMe8u6I?TNz}`t=gIzA`1tq|b3;VV(B4n(j&%Ll_PP zJc~T-d$=~1C3a@zU)83J;UpsIJH$~)t~mIYIUN2W+-q%#SmACd$F2w9N4Z{yL9~h+ zN3`gvtm%7$Og;CgLdkQ120g1AV%4A5&Di43Lx~o5iT}mf%1Lpp=QBRihPSmDu8V z6`7m)HCGjAP<%$sI4~pUrV7uci{~pUph45l^|5{o2cnMj6W&g34Bvduf!?13rerC8XYq5q{Mua;;~$z=8X+$gJt*HVIiV$RBkQUnYxN2%^NLlc z>bsbW%Q%A;GIg)gXBCesAG<0qY1C>&e(?IiA<&xqRNd4=^{WwuIm1%ck7W0cpP<%90+TIjpCSJ4XBalE?krzWe7tJ9lo;v(u^VhXRD zD{l84q6+<>Jd%y8`L&*F&`y*egFP*r>w8pmkn+-Q=3|}L%@wK48oqlKzj`?(1*SM9 zh288+H!Ga(1@*dZ&7vGiEP~y8nE?qd?PN1l&;bs$22MF0J*?Mzaw_IQVFtI6-OD(n z`Ak6r%~b8H$TO$VO!cn z(!{HG3BQ)9_J`|P?>+qD-dtr8SGF8Ci`=kvJ*>MK2_^mfRh2o9)OYPCNnjrfGl=M9 zVw%br?x_S_n{~IKt3nKel93(;G~y`Kr>r#Gtf33kng)Gbu!UX}Osm%U1ungQZgz|7 zRWGCxhFUX(^e9OxrG!ZLb0!p@)RlY>yI;(5z!KHZil@KKZ3VSa=@rm6i`W)b>0DAO zikg(}Tuiapqmv- zQMs32-;GP~EYuZ91q(#wHGaL!qQSB4ZsHdgR|O6CHq(5~-~`Q3Nr0&^lzF-L(8Fz8 z4@=7mcDjNa{uPWBCwY<>5e<$}FE`=6-{lavSzob$smc6e#nSt-q=fZqAIGJ?C6l8P z?s|+8Rh6EmR-3`^QhqgCRT*g37B3%S5x}CbN?EWcjS-L8+>mo@HHM)POnuHxr$~H* zrXZ}#xioqR@;pk(S;3;(oK0pX^C0PMkzI^v`qZ(%B(m9HWSqPt)tYs4md&>0Um|D0 zwwMDz9eV|IttVgTP2OfKa^TdEy#t?L5uaa4uyWJYor`c+@Q?0HT=elfcc7oO#0p`~T(CiLwtre(iZ>`3f zYmRD-DRf_~iZ<5{ZH+7Zjd&Dqjvd|ViA|x#8)(xU&$cF%T{3a7U9&g5wNBX%syo!S zIgxLzSN383;q061j%`gUjuFYjb2QhFY;90HV;YXc)0{l6)mL0&{UdWVH;ig+RD9zb z--@rjzX)b?N*$de32><=Re$C4yOISwZeBS{{jJcpNx<47u^Tt||P zQ6w8tz9UP>Xp)d9=Ud6i2_z>`-nW*PlSo>k+;1l{Z6q^M{y#@@sIRw0bX?Gxj+ijy z=#1KD!$GZfl%avdDCiv0>O{dCAVxuFQ>z<=Z&qRybPj8+iCQc*QWSJ%TWh0MU9Ux? zDCivC8XI8yy8%)Zbmm**QTu{*kQ4=-$F_O{IJ`roDCiv7ni#;7I*b$royWD-4d7}z ztP};Eqgv|+@a2vmMM3B2*5m-rmLp10(0M{@!vNmaw~(Ts^Q2aP0Qb1Jl%k-st+jCg z|HQYEqM-AX*39Spim$8hkblI*WNm#~Kx@^~x|j-^H{JfLk7zet+pk!ms7;hluhIHu7b_IKJ{T~YbF*OGn$nEl38Gr z{%X5BHF38l)_{1D9*sPtiOrgLToW5WJWUUXXX(*akAQfA9uV8;(N>!@u~icfXkwiv z?$X5VgDe^s-HE3n4~-PlRt?1&j{*bBrKsYmr~%a=X4=e8-hk`C_c)%d0zKKl&;~q} zpbaKYQqZQoeFTqUe>Tk!CoE`F9suDKYUEi2y$MexXjk!RVsI;--3r2|4elS{M-3Az zh{RoZDnY)H9o~+of-$nCN>+N<74)ks$SAfa4#`Xuw2Z6so~4Ldi)TPw%d%@zHi=0p zW!u%EM6>0DDaWNT(HQivf<;vul3ja9%BeXBq|vY6lyYhh;bn_t%9b$)OC85XwPOq(Rp) z$lI=05Us<+lvoC2|9}XS<*>teudIfr9OqDXRj-dFe-HAIn-d!Lv502r-E6avbX7tK z2^D7@j9h#6Gs(GA2^PiJu4_N>LJHesRK#{LSq%j{<(m!bpsNsCjG99J5ThUD$vv;u z;8VSh<6z1Ai$aw2PGA@dA z6h{hGXj8rA7**nP<*S${k<&6lydHgyrb0MG=b{lOkHO69N+{M*B4lgm5sa0qP^_n5RC2?@oDRVY?dLa|a3igl4ttb>GN-6It16`@%52t}GZt7yKbkTe_>SmXpZS9X`ZA z>-(On)_#(comWZaSqq<>@&YU?s>zs)xIb7EY%P^a*wm1#MXxmD zWZXzC@ea0NuQ=j^ zbBRN|%6LcT>JQ@?JLn9Dm|nOZJu% zHZ)g%SZ_0R!*dNs@R%KThQo68nfk+9v*(=9qjSk4c%G@x=lmmj&yG98Fqh0EkHo-1 zaKf{>h9d@%NgkVPe2YNXgU+xy*N|yAG7AU988JNPzePZqhLO3{TL#6RbcVT{pYh*{ ziG$;e$>$p1GPsO?TrT}K0kTJ(;W4?!OygU#aiE-0$L3OR6KJM!R4#biVA-?Ia6~SZ zNxdB-2hACmLSyPxyBQe_Ga^7xnAS9K%DFlhJxto`LoJ#u)^pjAdZjj6@*%pN&sYb| zayy5Cn=Oo>fkX3oYP9XtYZIy31~dzLCOw5lN}H(nHfR9AuDK&P0QA#2cc3GG@Bl=+ z;%u^`G0aFCQw50YsDm-(I(;zi4{EjDgI)Vg2ZK6r-3!WCNyJ`7HDwHnvCaV0V!M$v zrHx5@S#MZ*ZbQ@A5MzdX9z9bk)+6*Vo9&^*ad?|yN9dY2+rD&MkL>MHWPdok=?H=O z!;WAmB-*k4ph%9+Z zu~2Y$Y!DJh7-YG@rf%_aA06wwbfGsOTPKUB`x{ccN-ga>2|D)~v)m703R?==iIGM} z*_7_8>Md0?g42R@EgVxf&6s_Ekc@n)*8D$Zxdsb)SSUTb&AbvsHIopG!kW-8X_B6n z?9NhaH0i=Z-E|)%DOg{h(~B`AlGI0*ka+u*8e($S%LAQlwm5fu&Obk0SjR&HhqVLs zoyrMLU>TdmC|t@x8v|PY<|!j$+#@BU%#?7C%?t7(6TiE5Nb&8UF|X+W6gtp)J83)F- zqyph?XG!;iHp;+kkXNjguwE_Ybyax$=12v@%tZkcOodZoL{+U4YOb9il^~$z}jGrD;dV$n2)g@ld-dJ)g3hCtWDA+?ZJ| z8$6PDR*c+?7RSbNu1~`?UK;jDtvH^PEp}m231l-;?AQpYtaz)U$igTvVe=Pf77P?g zGB_|;>2fO;sb7aY7WQ+Q7CR`4ysgtu@lFcXD_I^UV+nk=Crv<}N032rF|o;D>rEB- zO9>$Q5k{k8dj}mK#y`l|k^jGKe#xlEjMa_a(_XY2vZRt!XhqPs;Z=?aCzxNmhe= zM#<*{#TDv+Le8V0eNeBOI&@!l-ScrF|rL*yDk zc?`4RcX1Nl6FA+Hz``S*NW1LD6=hp|5V_0{Pd$)!SI*DHdlt)B@iIx!T=Iq_V3sP< zSx}h8S!AyyXlhlGJGCT(5(hVMTzG!LV`WJi00K%P&Q&pEabEJu0t-BWoM~+IL`vJ@ zfKfGVRcjJz)&*`U*NW}zhxw*NT^45%ATd~urncC}emZ0=9c;CuSg8kP;{700$s_Ky) zNL%k%=AjNdL~SY$;xuqmm8Xn_9x8>lbVy1pC_ZTcB&po$qwstO0>hDF=TzBA;^I02jyq)_nHxDr;-3Dzj36y+;L!(s1I zp{l@)#wC=np4DH8tx{aqoS=U;J!o5qA`9bBsH4+A8^zc^8%m3~@{|RO>Wo2pmT;Y9 zA1P!qr5x>jKE<7B<_MFPSXX^5jiDAWSni=4ONGLW=_i`ns zhC@~%eCj+QSU*MmK~2@N2J=yl(a%#3_`NS7(n1WHDn6T( zkOYnxiqBF+3G!(K=90Nu7Kfd+WjIAPHC3CSI3H~j3FLUm$?^5ZAIC{Z4GQv3 zovMW7S-s^3rD;Cguxcx9r$RMBPmG2f`tQ<{#AX1s5nGM!SJ;(hbz<}<~u0;QU& z5N2ti>$tkYiB|`~tRY6vIPuWO)={9UDOI+HTXqD8B~%L7IYXR*8)#)r@tuD+FdmMA`9zu?S&4F5;R;c6zL@q}#$-ZK?g6 ztbufb6I4>vyCN4D%2L~wR`dRp4eCq+rqD|~hNQPIb#N4G)6ytkj~!XDQ$QKh{;*Iw zY-CxHMwRq|Z`Bx@dnxQm2k!{A&~qSzwB$*)DK92MY?5R^z?EcN0KWn4F7$X%N0|x5L@s~!f7OUmWzAqhytxzVL>5*2-qXxms zLg-XBdQeGz4fV2@bLh({bRNttkHb)^k#BjNe2Wk1N~hZp7T0utuP9LJ53H-F`pH4A zqxgc}YG@>fc|?ZRnf9Sw>24^obm?aFGd7_S*~Yy#>JyNH<4H%Gs^c0kEsax5xX`7k z^Xv42TX9WFO&SqNeDv@b-DO4Ux-42**YohL^}I}#*O499rKM=ZN=u;=;U0r&YW^%r z!U%dC&R+VW<0|c$rIM0DhLl^;^M`oGa?&DOs$piYc5wHZxpJBdiG4_HAA%~MDD_A_ z(xoq}x-}k)(sH6jkj3&jOVu#h4U5tt<8ra=fPz^Lnb;7N3L+yLl$qLYq>?{W-m>i6 z{{)c@+~j~tQFKzgvPec5!KKtR5L=HojN?-rN5QGU9`Y2aJx%vNh72o@r-w&)>OB!X zB<_P$`xqP0#|V@zj`UBYnO`nVGWk?oBi$sXoFun3)D7d#GxriyeJv)8%#8s>by5vO zDoLatRnzDF-8_2YFLy9HxYa3jMB$L(L9I@0)r8|!ysMYzm3$mzVZcK7YcaKjl;L3v zozqT^Ybe7ap8p|oxtNgsi?|!XABVmafDE+wTQ9N3njd!x!3^0bAd?Pl zm~hn7b%hy%%BQr3EO`_v(+_zX>^J5deMkysicmJps%*;3iaXh23dyn+r#>@PXW9DP z6b3tLRILZhp&B;x9D@^voOhnGmElNjl#&j-QdX1G3 z%M|qG470dH23arcX9pW(NXCOyXqSY@!{cD#y1?fvWT;(wQVq3Qo1fHV@82o^6sbWCL{-l@t16gT_t{FuEcM1A$~aoaU31Kc@uv6vQtL7I zhq@G$??)TQ*^@-PEnUyNgp@T=qNtIt6&V3nFjB5ae~dpCpM;aC+G3XsCgmVp(u}*6 zqvA60ZW(m^LebU>VRNt8+-puOY!qN)n(7hx%YW*;+aRmzt09i&+0TPP<>0uSCzUSb z(|6*N;-CanPv;>i|rcj zJ;H}=48|y(%e9FdRG!XZl1&nhN|Q({mt9s*)?k25Wr^JqXevvOn=I={s0~_*;&^Q| zw$lx^z+hblTf)ke;#BP5wGTTb31d)=r9T}nFmPTTF(6d-LW(Pg1k;6R`Ifr{YVCdx> zkV&`o#Ell5SzC$Q7#5O&XBaB?1U+-ar=apY>e&FZi+YLEloSeUhP+{b&bb2s#z;LF zZB_QMZF>Wcc$7yy6Cobt4ig^T(+!RYcTeYTsX~dBbA*gYW6#8(vK_Go6;xhIGVfwO zn8;2j3Ei&|kwv%@gYH!gq@2khz-(^HvAdB1hu=Z>cEAy)iFF)g_x=2bE{-H|B4RZW z5nI*B0X-aa?+to9-Yc0<393BLx!Ao5k4hBMST#!QnU!J>dE_wTLSPLl=(ezEr)0cm zj-eJBs#VmOiIGrtpa zH)ic>2oIWv@DQt21ffQV{QD#pg=;}-7P1i*7AnHwY$9P&J66g>hOW}9VOSZ6Kvou; zBf^Viv0j_#fqOpg3dx)8s~y4l81#uR%bcTdNF4QTo_uCEC~d&Kn(pmdH{{t+uMI>a zo{PyOa|_)aGL}cCt4|usL){&6s|HooyolfK3@>$Z&?(VKi$xjm?mwj!@~APWrIbPK zd~R7{LiK$%JtFsWMJ-mE_r~I8=4_^b}WnR#{o3fQ2IB|8}Jzm}9%4 zX6q~ltW=ZK+&hp3ECcXwwW#`i^l)E_&r-AQX=nXLHLm*^jxnP!Jn2@9p#*aYFDAN@G3*z2;@rDJmvMgzRZS!&DVNuwr-iUJl&5N zY?s`b12a9dQ5w2sVGqO|Gl)CIn#52^@o^jryQNNH9kQ}TI*VK4*iKy8f|;LfL3svi zh7iuu<;z$d(Px-di+HEYv!Ly$7YZFmU%k*wZrhSox-b+A>7{L~kXU(ULlpw_DUw&& zCz63CxLaDZ(jMgRKB<^g8*0cK8wK8`^SEB;ooY#|Fy)2_)sUPk`J5e4e`Nk)C-g&$ zluZi)Unm{JkuX4iP_G@8S2b-x_cBtY^I11?!TTsdA)I$i_UZ2nC=6T`>!ll0Lsw+EEG)!S<9V>Qj zpS$l*SgLW(*J-LS6l9O5wz?pXOM4Qk8DUH)s=nA9+kHO`+imQKkuJ_kqa!ho5izIB z*$mHv4}_ew(PJ7NZ1F`42lJt)yGJPv762jUaKflI=Jk~L9_bnHMvDXedq1z6wrO2a z5*yJ$$lH1FdUsOPj4npxS{5q+g=@3eESL}wJN#Tw)B^3)7ez#{-5T@J+~&0rBN^nQ zMjE(E2uWe{$r2nG0T=VvWW`8PfiRdrs;;`Q^`9s-@+{z3oG5V5z@jf#=k8v-)j^Nl zm_6d8mfpn7zmN#P zg+@LlC;)jYs2lo^n~E(`SGMq90tWRt8C$e+aDK2{njAl?8y~WgzVv!oolt!%_%`tv>Ig)8PNu)2J{Z!}aA!ocF9rye zULu-uHAeLgP`-o7%ec(hDZBdB%zMkxoG3{k_89_g0#ER=3pby&-DZRIuC z9TxJ@Gks4Bh<5JayS9Qqc(fhw9;d&uTT#*Xt!fFq)K| zHNvl^|9U-4@8n^RptDhf@mz&%%(XgZp)ez+VhD1vNYnuNvinOLWrkAdv`)xD%t#C~ znS`mZ{hT9qVw9eI2YPNjE1@Y^9?Ii+F5{l(9ZV~uo$W!NqG!7U zKctgee$K(t6@9_e+l1CZg<9Ums-m|;W?XtP;Da$;nUVnM69t}Wif5YeOsn!tV;(FD zyx?Om0A_Lcx+>zI;ltHgzNhAYeCVyLY=&6wXR(DdDBeX>J-0#2g+^Sl=F~fd6XL@^ zi{8A~fj+*{eM|<+u@rd#ab>MoURQ^~Zh2i$-pSr7(o@!N%JL^~Rwg&;N&-ZJXb=q& zSkR04&fX<42v}%NP4zB9q89OzSt~#_Z z_l>>HA@#n^-p>7^U@9Y_d`D8W;qNNhKf!B~JdjpnXi8S$TEy}mne0-Zhf(^y4x-*Au)QpnASij{h?#yCYvgX3FgK z7|=u5nW7^O5m4bW?p1bT2bXQ`)Tva@!&PLZU2c!6?%1w4I4U8q9A~s~VQCnbsoPNG z8-%P}58{vp)yuxnVose1R2TXbdeuyH;Q%kRs{LX-Evvq2)7pC3rnnvpDVCbLeQo-t`qnuOM{v6f^H^veZpg(qjmUPdd6AzE~!<_o!VHdt@OMh(N(+MmM8QMsjwdF6|y4LD3!u2CMB?H z?(%97YE4I6GBng%0xGxysj}W|5kUJ?+BQ6w2ul08-hD+_R6DZ0u2QA_ zIMG+5JQLNPiz&Ba)JOlYZ82S$DoLzdAeHasgi4C;y}t6l7~IpS$Ev@8&v%;`lAj$hI2+*EZM&*R{0@ zJP9A3qaKJas<&$OEO>Y8z=Af+Zkjs;HuGqp>rM*ZTqyvC>U{!@mNVco0i4kvaFYNy zBG(9@`pX>xAmsu9a7AtpK_;k8C%rV9z#QN&A{YeGbCPrC9X$z;7Lhps&- zb(jI?2eJ?$O1?AXkoX|Bbri5C2ygn&`f;nqmu)bZ)u*0TrbZv3LmtbG47?o?2ZuO> zn8lmXvGp4xXh<#{v6r8CECx%*B$59u?p?C3%N|kbJub%d8AQj9?2W zQ#%>G(r$C%%jT^-*8ZuR8lskl5+h#i-ep32Vg>`bR#3(ESwlQy((?uhmqtq=2$Rw=oHG{$sV}|sh@a022 zJ0SIILM&TIVM0FqfJTPM+@SIttJrj98{)E`F&qYXfQy-u#Jj6qAdknf9a+v-6n63` zCC!TqyLtXVt8LtBvYY1;SW3c>B~Im8I+~x51&&>o|I1;jl$@thP10m+hbS(^MsOEf zt%Kq$&Zpwd7_O4Zcal~O6;|<1QjaOg^5R{v+bRRF;sYLUINizuOHt$fWLvSfQ1(d` z`3OC4b%W(Pv%Bm$v&@e39VAOA+@QEa_T1r4ge-5FqpWy@lFeF$2~2SFR}#dkN^_Mqb0llA8-!`z1uT2}_(1_}=1q9eu_-MBlu0~D z_SCMo7ckXOVSQM92!&Z%E~QAKL42-<1v^jlDF!K}HL_!oIy}^$bDE%zOY08Oip|nP zEp4jm-qL2-xKEjjtubh5S#h|eII!gYxD2@pSr_^SGlN0tX--$^ISMgd*(t+)-%~SY zA>cS|ZA zvre4BS#0XyRg$bsEK~Eu(dP2o?^&+rvs#a#o#3-jjwoZkDBE%!So*wA15I=J1lb-P z(#T9k>+3?k#k!p*Y06VQ(uckTvYShf%0&pHPtnlr=KjTQ%pRZ1>*tnQ=9yI`FGJzT z`v#Vg^35_~PU0-P-_zygk`ZVxr1+ukhYsPSAKF`nl-Lyy&IHpU)4l{QC~J{_jwe zUFA(^Om0A=3OCS0wX7+0Vojtvy`~fasV1(;O-)?=n&6lkS0p$a=M8Ya<6!Z<4Rdom zC)EZ~;ieQz_nyRl4<;JYm0zYSuVaVkPP}(x?=M~*;n33y$n zuQG@|s3h_BYFhYwU<=O4weTK}7My%*!O6E4KKUlTcOtfS=+(DGPKdQ|FQbJ|YvDZx z@3H(YkAolU@ZJDq8f>TIJ)Zq8Z3jIEZx8Q9u@;;}fU~>7bTgu{3CK3Q*8pD%`XP8d z5%2LR8QCF@l#k%Dkj=s^YO^p0vQd&$t1}GyU=yC+#Y&~+##*qk6hS1kFNk6VSyZu@ zgZDVLRQEW7dl{m#5cIu9x;BEnyaZCPAF+7cSau{@%wD|~vsX{sPB+*BgLN5v~JJ*)9vsja%Vvv5_mFxri*>}dhLP+~n21~@A0MBMkV;I;vt z2Vi%+MXfY?SZVaI(&%BOu|<{+Td;JvbPft_J~)w$JrhyVZvxq< zD^^|=Ci1&yFTC7=LV;}cJY&S5Fv*Z5h)z#0yviZamB_RvmTI5Gj%SpCwBkL5gRV>g zjmY#a0n;L3y2oqL^OTARjRL8}r94Bp-Mw^S#tkP7G@#5Y}; znrP9}K11Vf^pZY{+pg4D~siL%DU0L_`XNN@H`g z4M3L>Lo6D7O$m-G7tOjf$z29gwtXxHsW#p80vhRhDBO&VlmA<`XOwOSCz91fMHRD$QY zBIO6iJx*obYzD(!5RmoN#OgP2wTF~=kbWM2Ott0e!J4?^c~yw-FRWK49-vUYqa?vd zqXe#TawlNl2!gZjpm-enHL$a^A{QY#T;6>xLE*B&aR-^9eql^~8aNwy(+aOjcxlRw z;#f}_N1{mmb3u%uCfnF^Evo0V*g<%Jed<7DUxdOYZK+>zftBV^(s$XU|s zi1YOn4EIf82^C*E_^?i#e+q~X|K1!FmS$NXwHQvroheiVq?VS~vYz6!1bwq9UMNUb z0DW^%tk4A;Fe*cO<{?uS@WnuETnOVLVrB1&om>fNAXj(|Tp%O4PT}Q1@n)=Iz@8RZymMw8R@AFe^E+lnw^( z2?{eoYzzwb0<3UNXMzQ_ijx>p+;(CX;M1QjyxA>|v=g$J^@Wk)ICip2Fb?zDp1M^vL~ z(sZh8<2dTT+5QOCPFH?0Pu@Y_?;2E{CM`=(GF}@7i$v#$s_VD3#%JkA6W?DWEeRpi z@-*9AKs~ET;(5WJ|46W32nriWjRnOP_K9lW4&Km(omr6N$}sqpLhX$dET@@u;4D

3pNXRU*(oVqvgk98o@663_q7HCl#-~YTOL!-OIq`J2 z@ME(fy*&#V@x`BGUrt#2eNV@%utN6POyc#?Un`wO#t*sV2M%H)+2sdt@mu@4$1>pZ zbDVK~ZDq=?JE2~?_(V#2{errM(if>LGP=3C zXA$7%8})N@#@AOu?}1~?Wv4(@%kFogxvw5$_I@PhfaB<8!qCZubT*F`U`&1Et#-_- zOxfg?+r(_UD^X-l*)_-h+L*le zZrV3S1sg-?(L>n>?P7~klkYlsyjkWxOuH8PzZb?mqB&?+>yFKP@9uhIRBl+bFY$`% z%`$UdxKFVLEsT4pa?md4DLyIvl97 zmN4$|)#d+uG^-5f(Y1PJ{KHVC_~uRuPAIAis7& zbDg=o57xj9!rV#zm~R`;Mqwi0h*w9k_ixf08-?Ekmcc9z&!hvZ5f@)xMPq&7 zcArFJw4o)n!J=`k;%iM_Z(%{tfe{A$qCO1wO@O_}JO1n1=V*hwH|1Eso8s#|xaUoJ z^%Ty#w>b#d*bp`}71%OW#NbXCGVUM=mi9MqKeu=_9<} zjHP@&bi9`ir%xqifJqIi6#r1LXSVm?VeKOZTazy;F38TLwV`Wf<^SYG@)fBG9)$8L z_FAB+R>{4GW3a2mAe^#-KcWd^)brFX09sIEJ>X=#qXtQ<-kN@Rd#uQh7w+Hh2_Jn~ zK1H5SN6%S_N;YYHaBrF~0I5-yW6ynf+O7c3_FUKGryHCSRISB$r1w8hlZ0p#WGD31 zXu)B<-*wOSQ!sR(ZgP^iJ=~xR28rbskSyGZI6iq4X+UOMEs$4(X@W99bqKqI_-C)r z)M|cCI9}^*v>Kcub*+2lZ)cQcq(Cy_D%u~Gzpb%3GNr~EhsL$6xIv_8Tew(l#t(9z z(mCE=vqlr={b>~^TFobH4}a_)R9tYgwRbr}LL!j&J-zy?I-?1WgLXOe9Ldwirx_5> zbH&e%AYF060<445=2LcqR@OOIj2!3@cKhX%XwC-;GnmvEk3^LToL(s9iX50-bdb#n#t`5q7b609~5)LQ_(%?Ww`$caM zJ(Gjp{GUvs9+@{S{hv_3X~?U_J`a-$l+KadWe?t@V0VY=NHb`2&AhZ1%`bfW?nD0c9LV1`Tm;g1@% z(C`!6b=H&SS8R1Y#8-&m-t2!C=7GpXl7&qyAhQvyD;7CLa=?4Q^f7Ibu&tk(~6-2Np!Eliy_> z5T+uATW~yOe8B$aD|D+U9f1N`zeIasuo`@>Utj?fhuCr<4CDYzTG*Aa+(8DCkZWGe z)S8Zqrl!3cb2e*nYpkiz)kowjeG>@?`ZOd?0=Iy03bv~5Svm#UGVDq$tS|{;KNT*g z|Hl^;6fX9cT@rtamo>{vrzlnlu&!&O1Q=*AaBysTSGcVf?^Z~FQ1)J!5{{do9x~Fl z3C`fdX^?+VQX$q*CP}kI|Eyu%zO|j$ZDHx*IJZr%h?}w-{C!xsq^Z~}ii46NTb z5elH>hHDgNFFZV3Q*vxRh`lT9P`gJ707fYNn&d3t*YWiV2d~!MeshR`IGG_HcIBr6 zTFNU)R`LD9bG<`IHJq@lEtIt$3rD=3(R#NQ(!oL~GQrg=g zb!88)cC+X_7tY_w3a)NXR(nu@@TZ85_oc0M#f}S4r%Vn$x*;nBIZE7<=i=AdsbQs% zjKJ@PL86I@*GW2A@VG8WuW)g`k`knPlODl-h!6=W6+@b$u%>Q8hm>bnoK-0}y;y^N zX%fLYSO3BrwhPKK%tewFVw&GA$olKfm4a$6P;`oV8x$_NQ$VjKV;?;!QK#EhW>r7o z+(cMNbwGRY16$Oxd2xC@!d~AwKIn5nj2db=lokrZd+o3z3+_QK@n_UI=qIQrJOY&1 zU|=9Hcuz9BaBT|u01qpoW1^@FWi6ZpP_n3PD>vP&8PGaINS&u0Pl^n(Kor&Xy_2M zpcs%-!`DNPB%J`o;B=aGLa{DLl{hGKQSy%hgy0&8*8Kq8sycu#=|yg^XhSp$5BNCK zpdIw12@4!>aF14SR8f%+HP2S_^w{G54l{vG4_OpnDWIIfKR|XvXaEe_ z5!^_4GzM5T@k6}07*oeOFCUt23v?jE5^%Yop5O=&rmu1QM2xsTdIJ$nW<`Z=jdTY< zj*WTr$NCP`j4J15wnC}J_01kPBEg@XcJ?7BTO&d$JfFT^H+6~kGWIZ87zuri_b%V^ zkZ<}D@}wx)S0;j+Zy#F*0CeC^b8--;XX^Ys*Svpj*NIsVnFj1k0!@p|+n0_c2RR}&BHnigyk}M$n?6B)3qI|XIz9uohh4w0qt6X$&@Ed? zj`j2NwhnVHAanWJe7|K<&cC1ak@b!%T`VaxU768)H59td!S|&ZH@}>n%({6Y_8nld z7IxKb%wseWoH#fckNXSW#B!)5XJKlW5_ciq?>I}SAXMe z@UC7!eUDpVk*4cx%1-6N-KyxeL*l-&bOHFM>CDhAf5;~H+|6P!ZeC?^O^;KuLuJ!RqG{BJ7eso5tDfX>6|EWvq z#+l~2O#ekwg}Bz`FouCQ1!3gp(lSWbuynK0)=Agib(7X6@g}Z>(hg;S80#6-w9B(K7jcY5G zW8a|85!k{uhpmT!4i}Du%e(wl-KU7PWY^@~XL7XxuR%vJ?(=K&&m9p*r9PEt1!rn# zT9uH1qBvsJ$;o z_pW=AI@hGURXx(QP61ZRNSfb#xXlEX3`p!0Tu$vz!5zG}rnsSojKx4v4l0$HZ8B4e zu(B?@#OBiMjL`=Hejf+26DmyU$J7<_Pw@&YWK>-fUKc!elwUG8iFKPX&2h&_cjR8? zo>?<3ti@12QJPnrIWUE!9YYTw3s37I)y!-VR^7sz$F>|dPu))moGu=_$E-s+gz_As zcyl(r10ho%F?ka<83Seo3#f?8JdY&2)6XhAj}N`$;}+dyR#N)}e27N?xw~c{N}`kW0gBEMWm3s2?F7T8-R1$1w*PXLX$z17yXjAj)Hz}oBjtLk z|GE5$aHM;J9zsP)@^1n8>geAcawmR~U93JgL0VIiEq4jaPouUm9|uv8n#%B^!EY0Kn5a0lSGzOgj3G3~CHzcW7x)N@2pJ9+evAQ2&28v2CHybfui+n@qJq zHOwpjKNxx4p5dXFNjo~7PvNSR$X_}{q-haH&oPLVX&yDkF1?r0>)Mv-p?@r-JyBJ` zan6MGHR1 z3QFdG$vur;nRkZQ6DeMRk)NEF>zN$qN|~OeV}hD{x%7XNg`D_i#jAq9R*;!6d`m~( zF8NPb`)knccO|vBt$cz3#`iS1ivNt81{4`_hT7wam3wm9uHP&9HRg#bY~!@JWh=8N z|BW0`b;U_-csrinIR{hW7PRV#D{r5u)h&0{8Etv|dAURH&Y^zQGhLy(WX7rD#*o48 zht^r=sO4`L{CXo9rgZdC%lS0Jd*c$Fk)>1)kCGT;dUIU}Hf%H2bk-QxG?=trn8;q$ zr1@4+Z`cmE8vFxy5o^<)&kTlJb*^eseeI|>{u_5=^ce5g+>^X=Elg-L7v=ZO zBrWp{+h<#}{FiJboBfBRQ+jWW;@UCMt99t7p~X5g$2m@>XY|KtW(})V~siWY)9d+`&HxGza5q|VF`LU9@Ygxgw7CcWFe#> z9bp&MSMG^8$v@)z2DyH$B;+j$%DAC#lpNdNV)!VIJ*Ccm$y%PM8i>-F2B}A#hh6?J?jn+;KcC4Ddum+erufoQZ~Qmz#_-YKuUQP|K%!VuyEa&; zq>T+H@#}NYD(+eEFDBJI*J=PP;y5`5@iTW~#++sL_$Xa-68R^Fi2jmYMDi0mPx&)X zbH+SWtORKrbCZ`RhVAz)T3k6+{!6aSb6r?lsGS&XeDU&1>n3Y9N-$uNW5)fS_FiN3 zUBzzjoQt?^`+v)S6o6!&o6#Ec(q65(6xtI?96%MjSp4TrQBJ+s>N?i{7Werp+t05 zi`TrNt|hi$^AD7K3x8j<-G$dLk9Zy)UCgj+uSTu5Fg6tz%nh{Hq)h5RtIwdf5STSd+|g#zrqo zp1QHU)a9QX*}7KOBliDSjNP2y;SN>>ZpmC2T*$u@srW^U{qP+oUu!cN*;gY-mEpg| zn9bW`&ft8`hZ2}>t<7}g7mXlOh6}}a{uRGivHvD+Ag+tQ$XqxQCK$kID2mx4$uUD$ zP?I&oeNPLV!}urh6WqBKH09UU*tE)`l1l3e27}6|{~uC*jgRFS^Qktr(-}A>yMJIBpTqii@zfDVrHNLY*$ItA*Heh=SQWd>hTvRq_*d%uYwFrT7WE+3~cJ% z$TAmR#YOftRECVh3y?5hEjo!c+7@=&nXQ#$hQ@m}jB^@$2h4M_SGVlJs`!4EcB0Fm zNksp35wWY-G=KBZfst?Z4cj}^JSMhpt8{h_xnzd4Lkp}_8&ZYxGfqi!9MYdPV~!V= zmNhmOIXn`lTqqxa9wp9$Q8lUPgkdfC^L&lOTC+#3vJEeEO{&)2Q_zLU62lUJ&w_6g$!@e#;Byyk}v-!;rm}(I3Cqn z=5Vel)>Qig@&KlTz@ElBl(BogUExmRjjI#e&IFLeq~nUjWNk|;r?+5ntB=R1(>+Ab z@QTiCg(SkA5jZ{`&BhXg7y@Zi^`UXpd23~gLY*L%Vo&_8(F0?da}Muxue+~I*Cz5+ zScMv)3g`^d<^O<0K)h`tKzHTyP1H1_OdVd=f5B2CK)xQLW27jmv52?B?fwr;<^@pa z89OLm()AZ(#cK#D{0(kT_)U(M=UY%(IaWu$F!t5_GYCD$FkGM58pb*C19u{>eJ)8+)j$kNr|5imShJ-CYm9$f#1z`=C8lr zoRxWsc0C^oi=9JzqfPk)uEXAt6x@?_Ash_$}9Q`*;SIO3qba~$# z{Xal0_QdPzJ0O-hXY-Dj7K~Xp(`oBlr6&@9L>!S-6A8XTPl+$^h1;d1BNcCl-i1#g zRC5&jJIJIEsyj-xqwoF?EIiAcIc8m0_ZB0?(+K@D;Ky4DWnEei6#o+#Tv+!Mzl+Ba z`a5iamU@j17#(Zcnzt9C4F46v4GA3`+M2f({uOo>;tT~HPurUR89eb%SA#q@SAv`n zfW!~~2DVosooIo%4<7#;wpPNNaDm1T9{&of*I~Y)O&GOxPJqyn)g?RvZPFYKW=(v5ETCd^v$3tiZZ?axcT>hm&V3qrq}x; z)C{Q)Bb*vV@o&Plk7~xo0DJ*Kpec3!@~k!x)gY|4G>8U8L)7AJ~lU!3|-BH$?&B`LaKJzUcp7!d7%2ZUif;DG`v* z*ZE=lqW@onJU@57&DH?p@r#x2TC3;Nssi)ZyZNC@i*^g#=h4{}kNN=Z4xadR!i@Vt z3*JP(OD+i2RZ>8)Y|Nb|C25g>WT*?>D_LRGat^pa!{4VD1ySWf&7pzwJI z)cxd@3aVo3mO16Ntt-BQFLo-pqG{$m{2C21%;9(HdqMR^k2~+2i!1S=ZX`Lcr`_n= z!D`kN5)HqUOUfnh6yp*3bZ@}24A&58@o4eRB6+wpX`HMx_+&3|t;i7O&JU{fyX>n9 zd9#E7kobr1=&%kXf+q3gw6n;k)|Z{YwMnq#-g}TbtF;|;Lrj4-zI2*&8gbM2cJa}q zcoS#_$l=%pazQ8!jCi^DO|slrM7xUfB#5ByAV;h9ogemLp9q&d9+Jd6BPJ4Zsh@cp zz+{55cN-S_A$KvtXd8p#J~aL)sjQUq>=T*UiE@*66B!xnagmv6b%FK_%UlhXnG3DK zCnhrIv{e)A2l}3j&Jo84?AzyO`p7fKWOCCYCbzoHmIiP{{ zb+J4rd!{&+|BhG!)74>c%&3zVum|emiJq<+t|e!rSxE#mu37jDp(f4m>Bob9GR`~$ zX&2bFwfcH+6-^o})e zb9*&&7r98>|8R0rr3sMoyTm50bXn0_Z##wP)398P^ImR*Xp2AQGh+B~zjdj8mgsy_ zzy5yht+uYteBJ0>LwJT7CnaC_R&0zN`I8tUahvW^|0v=o=4++ChyJ0M%T=#**3+$*~{f*rqp zI+6e#`4$RHc+}48beXIp)Q)Oh78A1q*XptHofT1Tx!U8VPo_M^km#SkJz|k~n*l1> zFENZJ0B(|7#aF^SqQqlvUR#fj%qk~f9=c|T?DRUY&82sn|fS8~ZO zEa^DSr+6z#Lh$r+C>c!67^39#b3c;c-4h>@e z^CZUz$T)lI(aSXD)cNXfw!JM@774B>2B+pFbE>!jZMR>8vXy>P29yj4a%?PLp2sJz3t-CHnP4V7RA$e(4Q5{t=38#t#DWvpRd-@(!eOO%ES=<5w@I1v;SUL& zwx5&^YZmZOjSAf(_qp$bH--`&^iwE(I<*)vCi$=lNEh1Hez*4s6Wkx?>g=M%1)9T7HK{gKbH*{&OuJBwjnZ1s=s4P&o(2wI?iW9yW1 z{5&8+ogc_2^LdvplCaUja4#nHVQreUB7LlzO~wUK{kwL0ohovNR$h0DDzj0+HBuDc zv|Rn_y*U95(xj61K?YTR%5qKpMPo z0$dxTO6UJ6lk5KbdSCMNr9|ql+1Ubz4gjW3tQEcP=y*CKT7#tcj1DEQupFHKPYFn=qPQ zHo<>fY2?m{#&rRMtdN0LAfIUqS4Y6)A|T%=yOIkH0hwmhIlcB8Ix^m>Y$Ab?RxyWH ze{XE|MP}S-?nP(ZX~TAsFr1B<}BOZ8a>ADfv)9f z*2VQpW9gLy@B}=#=BoLpk$X4l;?_5kb#H@5yHxX6j9wDOxLCQF?OTUeOl@q&z9kr_L+cs4of`Mr%exH`)ZwspN=An? zW6c-5XE^tk`|s{!u8STY30Sv?ZsXp?d*A;dM#;IJ&l-FmBx73k_*Ut4lQCG}WrRqT zgVcleGqPu+4Kw6CF53bKR=;R+^7t|B8S7;PAaNZtul35wvcNpk{%);TUsXrl+L5jr~ztQrMFW+MQ(6>QRT~ z6V{5+MTfo1+-zAvuk|uYuXQ3>k)E2N3N~k8^E*`IH;;Y)pa!*ET>)}H@wEOGtuf=6^^g{C=4FDW z!=83#zJ_VQew~MO@z5M^R^shMmuXRx*8bSu2GPFbGQtGs#BHg6Rc7PFasdfiHZyW& zzE0Is%@JKkcIVLwzoUz^tcqL=OZZq2s^BCJL449&D7Vn8t5xE_%7-Y?w@>z zWR`fC;dCceNP^qFRsRyUS3hhW2@aohxc{6i{0Rt-Y##~`2q^Kg=OWIZ$lfv9HL@dF zJGt+>60=stX=!TDwnF1} zpLJTpp+EU?y{Y<-lhg!E`X7gjat(n4Ude%PxN3^9a9B_

4_m^g6O$ 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 z

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žuu9X*{ulSjk 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

wd_Ly-FMV!`^>M<<1x6uL(-jZV@zNoQW4 zx}-ZC8EJp`YO%mn!5Mp%n_n-Nn|M3G$xbIb?~&}>#eD!LpPhU*FDIYxnPj&=eBDUQ zs~F6^O8b8{llFKQ&`EqJ@twrqY>chk0CakV(<{u&=@oaW~41X`im;wpt#X-fDk1dAzX}t8)qNSDQUqPn)HT z_fDmCDy>s#ol1MxRodzx+ev)yRA;9;o0n6aUCYC3dEiQS;nPWLD!5MPyEj1gh{~z`PVF}@r}n#+_o?NbG8hV5eF8bv*es5S38EY)YvS1YF4JN4bxM-@3-XNNyD0djZIK6YMmYG?9kdVoE_@yP-llaJM>Q4q1A!r zZ~E*he+AUHTE5O55f#N)SBzS%mFV$H1F)Nj@6CvoI z+-&U6yx|ofqX5NoBH{p_Nff*ivMemn6}v>OU5)1XabV*W`~|dZFP&)GPg5B03UpeS zM6olP7mrv$zAgDAt1ih;$DvrYDG%F{+?)xlXJt^%WrB8*-{$xW|MSn#9BGLgRjydjMG zxI4@l$@>Pg2lPIB({Hf&RcG194H@{u4=c{`nHYt!QpQ0d>RwpG73qL@`Xo&zBF$#r zC3VicK{nk&P{4g)2i`ChBaMMCfwJD8^fXj0VfS+w{|RKKNmp8b|5cEOc<}c4BM8Lf zrNRV9J37Vx0cr5pl^mRJ)apT6SmH>-WKLHrQ(}4ldio0um@^Vm>&XA1>Io%0OU+#8 zG+S$P-F38UUrAIwZB3A7%+*Y;KDA-IybP~lwq_MKVRluVJ2QrXK;{a#S$1(QX6*oQ z&E4NkC90SrsN>>hKUi&M72SL4ku|nAYps@9si7~f(&R=SGSgBM-Hd0cPUf?$75UYj zWFI9+I>(H$Vamd5We-hL2C-N7Ol9Nu;-pdbpF!@!^U|#Dm8q4GTScII48&75n(|y6yMTgo85~gUv{u;_K zOVVB_UtoZCV|eO-ZtI*ItvEHHKOBOx$-4PK)bQ-cmuQDy+9x=cirN7sGP`=jLu9EB zvQ+v}CGfskwUcXxMp4+$;_?hxD|Xt3Y}9@*!defQnpx#xTDwO6gx zkE$Adj6TO4YgVgTHD@Q@;YSi*CP|oMEWGUw^Y;J|ce21Y#p7K%W`W)n?0V8m+EA#W zMObq}A9|w5I?_0CUmo0HxqbH53@&6LBG{Tl2uDDOv7dq@s~~;aq4+B0PjiSgX!r}B zL?6Ah*L3_I*HI?5IgFjRq|G!D&3clc?<9>eT2xs~b#{snNvEt_cK+CnP$hO}hP)!1eoA&) z%9NQd^*+pjps!aUPBQZMhezfHYNW#outqk*K0**AYR`=XQuZ3V;z&Sr*=$%2$w9ik zlX+{0tu=~*^(kRfsvZvVfdrQLt9n3aI3iIn*mtTF-7LCcCnf<)TMQPOoH=WC>RBUj zG4A{PK)=7z!)zbFGmbor0Zg~gaN!KT3p$nPmpnkV<^zfH+_`MVQ~fbj>6|+&wR=A6 z4#GzI&h>bOA^OLkyV#i`kwYH!i4b(dUE-L2$y76pZB$wimRuZUjG9?Z$Pdr>WzL(s z3h6edREhMxZ=90m3JD7!wP1Y35>J<&3OO_2l z;V}6LmWnfGOvLP~@@yGsWwZiLv6rigURX7I-9?BfNl%Pstd^)CYU>U=X7rsooTH}Q zEwa)dV%kJg6^sU#d12yCRfr?Xz!b6l$29{%3?en>8we$iLCB6t!*t^fc0sIT$=n>u zjAd0^;-KvkQYy2O>h>ddN%0&XI^IkqHX?TM8HE6lll`;dOL+k!x??` z#0MlPbX+&U+1tVRR^2Q!CPKp{d#SO-%uf(d>}UVU?^bvbbg8*|hjK&K9r74sxzK^Nh3XbS+M~ zdF8zP4~CzCmN91|1T2@!k2aCEsX%R4_b8iD8k{?*^^cMFo$zg|t*4zZqqo-XTF9`m z%H;&`$duYUXgmIWepPRKppL$i2keQ!hOD%1sih*)719m4*rRY9j1$8l?}SQzB!7|oy_SWq02Y8UL*EEFW{QhGyy-ufcm|1bveX~QdJuHobP_&re;R+aPGBDs6 z>wiJy(mC0Ev9~XA%o$JS{D2tkt)CF|0SBT4vYN&cCa>XTGz!PMq!)Kx>VSDwkcyF_TJN>trCj zk*<0Fg1yb7d)Gip$~SL`7nS3&!cEYORoT1c>|!HZT(=nIdi;=2e%xhOT&?jf2chr# z!)R&AKeTEK`8Xp6r&n-#r#BM&8t#IN5Px~lel0!x_>+SEuz8G5I;1;84FDD&4pw^%Z*WY$7qH|6@?rQ3AI#5?hsKGa zvh-C3k0g_EJdVNYnngHPJ~@Hz3i&h|gq(WCeblg7ww#Yg#l-GaZYDh{UFhAq1!DK5 zJx{z65kj^MRqx#|Q@yVE-u3DZgY3%Dw60TZk`L5B=K38Lnd&H}R+zM*h*bxI2MMRT z4d7kuad-XWe35=U^UGJ{N*r=m!K3UJZ6sP274}{%1@b4t@KetdpRcLezz)i%&Zxxr zb4qYH_7ZHWK);OOHxdMtr{`9Ai-?6iR$EY%;-D75Qw^?{vVmaGu@bwX>}nPhPpfk( zYL*K9u;}rTKov})TILOg;fHLmizKDXD)1^SShH;ss z$T=6-p8BVpC>KxyYux)O3^5WJ>G}FDaymIqvo;Iz?i81+9sDTQ-=C{qE}jSU#s~F= znf7fpIm>4Vdp~lnS{&LO^?U|yPu<3~DE<;l6z_`@=1!G#vxz(TMF;Njg6)AnM@;b2 zP8UN!3KDLn$PwzYTGkk9|pN*#}-JzQe1)H>37{GqLK&5=2a)WF@ovHK%7O#_#$eH3JgbP zO!6zpGxSE-s}|X*E~xg%Z`#_FnGnU@XmuIdMzS&qEe`-`(T|=t8iH{Kkr7z1*ENf3 z$0Pb=wL#|Ed;~p#36fUFkeA^{ zbVQ`@0*9{k)$oy(w5=Jq-K=J!fh<;kvF_{&Hm>gyb1WA(%`Zdmy-#pn2KH=D#@NJp ze>ZbOHiTWdxS)LANR|=gc_nD5esQ>_g2=DlcC3?t;=gteREvf#OQv zW-_T$oc|Ug@w#@`p7+@{N-31c$?*^|g{US&BmsZKl+zt~<`SgwWFw59Y{wZ%Ydw!0 zBEIS_hZ$^P>B6)U1r*v|Wfv@6U@bjs&yZ|65&2eYm@cT)k($Q=bxCt*UqP2_UT!NA zcEBfQcv9C)N53Wg0UMPASN^6q2yUdB%S1%1zSY?EQ#>3=XsHbcU-#QHON=brQvW4a z)o5my_wve~{=X#X%qjiK8@ySODLGpzrFMNrQu_F$q}j(4t&g_0+F}su?f(caK z?gYW{1y{!_xX*dLQ)l)+@({S`BX?gFb zny{t>eUFKPY_Y8oH@4q8rWNWKQB>_JOgCN3&t($-9C3{PLoAC!PM*0MGzj{$zhEn~ zm840|6oI;1MG$o|o|b`)MpJO)b(| znB-vreoiF=Ow=N}a;uEL%)ze>-1kGobAzGHH4qdG6y9Tdx_$KfV5IbN^PO|Jt4#}D zR`u(NOxgv%5uEVL*NcsBpRVNk{ZlWSSUA=xP6G!}L9Fgwn9SdrqYDEJ8y6>>>k4h@ z4m(QCGzQ!qa=nfe+E2hss3$qik=brx9^}|(6{aVHB*<yW4e{7>tU&mec6{|1rkA$nur?6ZRFBmGUbt5d- zZe6@VxWhwG>vA)j;Vf*ak;M_EOi`^Y=Ov_6t|f zj_lXZA#e~h&}r=x`Sb-MX@iMKt}#-zOaRe41UQ9pEbK+_vI9Z*&1w&s7ChRhJVHui zqXsP(O3uMC%K7)84eYpwAYsMdUzK{+Mflw8p>9$CTJjhYei?K`Rp-XHiMqu-An)kP zPn}hn6qHs^%q_m9OxN#~NbG$&&njEjiX#>N;rYjs#Av|rXd(QN)u-*I%&6qklCf($_CsJ_M%zz zOd${|jXGHt61Js#c{=v1u3wn4c`c;uM0%iTMg2B!UUdw4WW4$w&i-;;O@x&!{j^bq z!Atu^5%v($Xwfvr>)pOtT%xG-7$Ific$`N6O=_v`!xTr*1#9LIck5Bk6JF-R_6tuey z1lY7_=$g_`ngKhlw-ensNSE~LoOgmz`;&8(sVWa|V2`n$v#kT|kMJaWt%B1nIZ%CG zrnM^LR5g+dMN2hxUjIm`{ygV_VaHTjepv%HxEbC|P8xva~}8$qhX#GtQ()QllluPab??Qy)~pne@5bKHNa-k+x({HGAZcv?(&5s#1A`_ z*~5_KN|SP!5E^*hwdt$C^ic12hq(5-voR$)&iEB~AcE3D_v5-|nh*%VGiJW``s zp6fH}S#C7&=Vw1hO5Wb?842Tb-)V=+j6d+C9)b8Y`i~c*V0`bFTwuD_q#_^|l;6B+ zHb^sB)x)f;-;4b9`nE)- zKWU5l`}LFBWL77@-S-gJhTteWxx~zJJ7`2DWCMAZRtZC!A^} z{2ZC6b`?ATm)rS@>_>H{?cqosB_D^AIkm5!-S-(-J#f@|tO!u~LING90M3^$+lD#Y zk^nr!fs5iCj`RZn@9r5tYTBGwhK|LbJ0WKQHdR_Y#`tPph%Nv5>=&&r)p zRdv1nnTOkQ$nf?ZWlEhzY_4wVK?zYyA{Voc<=MlBPT_{xPCtpykTN3D zxI2~p?04V4NRU;a>ZeKY<%AonzD)I>ViefpDVWfx8={CNwPqWM(8SXM+lda-m}D&NjMJEE8<0 z69PSLHNjZ5NiO8GuOqaYVBtZC*NN9p2y!XO=%L7I(^E0T zag!q*AQ$~^X$)b|GOJHXZ81G^X%1rwJl$(ytfs^<1fOGI&Fn;8(3Y&1nMNGlELRlW?$`0hP*Jb~!&=%$SJ2HtmW)8<$k8c=`ciWo^ zVpp6}2cLo zo_xC2ylZ5W^E`yBEF`3M2|@m%HWB>e{eeC%U`@in%IrJ8AgX(EF+PcxdfvAW7~=0v zFE<|4<72=#M%Bma-dWOvJVgtZGio?I&EnPc(RCWskHiOv<&-t9Mq}zF7Lh;crUEER zRn{gPrmo*FBm^{uFuChwuv$jz@ChSnW|dmcjOnE>WgU%8Scf z(x;fi?sW7Y`jVQ}UME(U@|UulK4x572&R16-Q4%j&OL{Wp{&GHl1d&E zn5L77OLoK-zho6-H>e23C0hM%cSctDV96WbPq|?QkKd-Ue%wP zE2C1jy!NR2)@h-OI?2QuTuPf%W_**vp0xWWY{b0~VeW{5j@lOKil@)BBT;-KP`-iW%rjPBM>D%v<5w9W#-RhWWk-rR;-1|ci-pz zvjW(+teL? zN`^3<>!etGQDQS7V7MSS*j2Gto}{h?tFB>^QB*oKAA00y*TZl_2owCsUbXy#WPRXB}rBhJ*{9W8ajg4}p;Q0xW z+-k_(gR*i61+^sZ_d!Z-&G^t(>YKaUvWqJrk0L_Kow(eU6Li+1LE}5klZZT&_&S+R z$JvKX(E7NJwz+91fLh6Fs&X7ed0T8m2}|c>>cF2I)*DufjQ1Nqw6{G|`v{N{@xMgZ zi7*)H-%G3J2jT7}CqDzm0i<6AYSPSd7t(GMJSbv1%vB+ThWz3u?;?2$!LI0%pesTC zRPQ!zc2^KOld$koHh{yS8||aAib=^-AHVEeOu*~1$M=O z`0#$AxuvIXR$vIUe)gUS%e(k&5g=5BMnE$$=4b?;q;a~hL0QNxipXRMSqinD=C9Is-rCfc(1{rfAp_{l0l4nI^9B z9$JalN=URER$g)9U>esO`Bkxx`IYG!6i-YYL-CW!I_!vf$8~&lYTVWMB)W%GZGn-n zYj06`K$_C&1pRI|zO})HtNSjM9zSZ)TU?(IJ{>j7TYo_C&eWDetQs0?!+M!GZo-rw zhuyR&U1iU_L$7Ja(6Ng{QlF1WLGx1;zjJYNYechT5~-`c(Z{aBIJKBupFhz_NU?W> z+cQ}04eTkYs;v}H(ZvcAU1bt#l%i6G{WwxDf3{AM%f-3()jrCAf2VmX>sdhSwrcy)}BQbPUA>ug^VnOd%{&- zGGpyBO@B|kZjs4XG}&N!(Xm3cqBG3v0a{Cg^}O>ZXtaNg`61721bR4q#QLPy;)Yw^ z;g-_8z?wWdwfeP%RsEY zved)?$H;FTfgIRAY^0zy0_jwo+FubOzo2@BhbuFyqewV&kjF)Z9C8rB)VPP~e-p#%@P@lmd6x~9zKZ`>9%(^!JxI=j4Kp{td( zmgQ3u)h`;ce=&rG6nx6gF-$+Ptx7hkld5XdS1ADAN%IA$JDA!!h|#;5j|iqrAiGRk z3su4n86`W2Lg3<)=NJdH?m6}Ix> z{+G1!_If^ssZXmp%(1=8!Fyo#LEygCH&Ej+(;UT>2^(?x2#OhJ#Y{xc(9QjxP?bVb zie5lEUOBa3^g>}|jQ6T-pnM*Zk`k+)FdJ10P19SSC;ffgvPldZ^QHG}whDHbDP_WE zs_vAb=Zp;*kibCJiE!j#`bM^&&vCbWG&er_qjv{{1F-an65};d;0AqUonC~d>kc{nXuvY@ zj>q=ui2mV{hG*9(5`o@v8g`q!^N!!nULeWgwWBV;?bYcwEfh=tY8mkJXhmE!g^hRL~1IISSduw-11~ceG zkcfz0zeagw2KnS|j9@ff7qYs?a=J>bznCc|$7Mm>guybdpvl;v5YD+EAobI>uXC+q zu_%=bSmrIZL>ztDHPQf6|KS`I4- z9%2mvH8R9FsgolIeky!7d;DF_lS!X%-r&mGYn-TCdnSui ze@79nw2b3A3A_xCD~3@tKX07TLT%OEXcK2OL-NShQ8}-fvpr1vNvs;3g4)!spqPq)k z1K?w}#K%INTq!{-q{2KC>X{=%Ae!e5_b2ypnn2ZXyRM`YiXV zFB9=xW+3m=!NNCMBPg&Rnh)}i)^Bc#?G6{od~Z(_G$!EpO0bs94bpdduhSmbnuNnvE zV!xzq*^eMXJRsmcJU~b6$+IiXe`=DOz3y0p+>&}-{(96n9W@L)m{MxKhb2%}A46K! zWG=Nkpgx=kiBTQjBwX#zDd5c*qPP554^BUyzPA}v!}kN$JuW<+!Gf?A$9kca z`>k8m%NLchd#M#AF7mzS>7=5pdzM5mViW*dM%WyYN-~S@j(&Qg4_(ojOEHt3W1fI_D|HvPaZXC>cY=1fOYX+N@_m5!RMS1(BjsD`2 zXCrfpN^~r*Z2y)Qp&fXZS+?zh;rbz-L(5FpW}sJyZI4>;mYvG1)5Q-`2}%p{B$-|t zUB4V-p*0~8y^v)?neFEdU~N>trhm``U!5Q#CHtudia=NkR?a28Mb%3dPR}C+wQ2wk zY!E}R+zLUfFT~zHy8I?zldNXWQgjW2M#s@6P)p*%C@-yh2?|No*?I44UHyXRF#)9+ z4B!m?}3f50btkkS|M508xS(apL zh}niTVSzF`FzAO-Vq#PbHo+6P6&5C1UC$>d(*(3V#kUtVq_XHw7>}wn{b(M7Iopopp<%If&YUii z5wULkeR*HhHEG5!RT=K>I#BX{L~Ryq4Ur{}-3zao;H{|4>xHG`ovKUsy2DWySNpT% z@RXcV--0?ha46yzxSVouq==AtEPELCk0)#l+G;D4soa zENQ9&bKMkp39EgpWH}EvduLn6b)qYd_;bUyNTEr7o5)OfkstOP;RAZvRXG!hSEbl^ zrn>59-txK8v8E<_zXBSJ?EXyG_AxgqN4HPXDOXdnm!G0qx?+vC@F{ad9SMWzsI$Yv zTq{4Aevw?k52x+bejbR`G?(dWT6-7XF+uqTk5|vw2oI%H90Slj5Z^38j@S`t&;waC z>;Lw_T@PdL%L0@q3m7T0_jOSb_{GA@`aKhGjkK9oO_CsPbPJXlbA8;3Z_kZ~rWrbH zVf*$z4c!B}Dw||69vwcQx^0QVt596k9^ioF1XRlP>>lAN{i9_rsgf((n=^#w%+LZt z)NyQ+8O%{sAFLL5i4oD(FsO;HZ`SBP+Iwg@0e?{+>d#~ z5-2$KS({dK)ecoQtn_{II?m5>^>z{sBS9n#x1=`gpMGpUe3zY*!Mt!hdSQCqtr8 z#Qr;2Q^^SXV6;$?Q^INj&pNl*;J9JqMcc53-kgw6I<$)VMVtMirar>uyQj%`%JX*> zUntkrc%OJRnxma zFB562gC_2DByYn#K*C86TdIjQGMw|nl%BZomI=oK#h<}EW8vqb1tZa@wnPe)90Glg z7js-y!<{7XWzBt?7@!=rxG1cFsHgY6duQ!s;iqM-AzId-z0MB&d#4azX7Jt-T4wj1 zXw=(Ustm;JJ@w)nt5O&CpH*eezfrfNV4agDC1j37bRpv*nlezPPi33uxxRQ+lpo_< zJx?gqTyYcsH1L6{35%r5lXXVg ztWkk~If@FJ>o-y8;DM;z_C4LSO;Pjc<0%_sv{vrel)1Njrpj>0X$ipSyOhU$<6luu zLIAysn~yrB^kE5ON+#WC0&r`rRhCdRrWWU&qBb`24(=*BJtu1J(_Fj}pAiYo!slSA z(x7!#eA0fK*ssHRMkJu)9mj5!VGedy#r;5V(g-c~1Dp18e7xbe0>4;#iRw+P6#W|u ztV)K@!Ftu^A=!g+GIy#IhMH>!@x+u!4JXOBsAnA4=avt~?M|Z5Kyjs#(R&_Yv=Vru ziMuJGK&IMPc@~vj;~CRka)U3S)bF(ELuz|l`u0z;CdVOOHe5%na!iv86(mi9Q(X;{ z;F7A9SnBrE@I5O=kX|3I*N0rSKP}?kn|guFZoe}=_7&rxHUQ$k*NyS|2|4Ijlx@-F z0;cM+IqOa(#yYzj!07knm~|FPQ7Q*tza!EZ0A}CEPQsvZ5NH8$Pz4LJ2z^kWPpZ0B z)FSAU<~Opp7}vXBvM+6)k(6^E!Yz-qJ_mkun3avrp{TjpG`w2=mXj>dgfP4xcIc*mrhgLE zpL!j-hq!i2OY~egqKj$v(m6PP!Rmgl`Xvi zZOFW@xhckobB#2&C6yTlEEl*b37qi?y=jEF{xYS(%m%yFZz`^5+(i(?i78YKD_mCX zn)8MFb@~0lb4pcv$J*dZKa-p%oD8V~ODdcW&wwBx1c>%jZJ`|oCcXi0VHRH{8*4BVeHb_EUwc$B7rwtd5`a%N zu2D=q+lgslKxOFOC7JLbRQ8`(Don)#jieDA^6cHcK3|!?`y{Wr7{T_Q4O+Meihh>- z4T>}ig78~Gwxc5AMXID1sUc#Err7&d+h<+qVaG&|w+VW|{z&qJiFJ#39QxlzbE38r z@Blcmaee9*S5kD_&L8^1(zINqRE-fvN(GsU-tGwX9a5}k!O}andHC-)0G`4Ge|$B4 z`Aif{`Kcvgk7Vkxb@CoVK_e%%P1kQgDwhau7;XK<@3(v$!XFZFzvbfq-J5mJP!JHm zca>N9I42V`TN6tF3kU#owKfBQSnL5{6LS-=35%H{5WwUFbaVm$!Pc)AI5+^@Y-YTi zX6)u>oF*IqUK1V@3szn}PA(1}Hga{tmAEXKb=pj01?@+)R+d3JiAQXJK)20opM; z0xen0%~$|-0DFJ~7{tQH%*I0Tr!5!&v5TZ z=vDTQ%o;=nwgQmZJA%MuPL574b|yeF69;oL3!pW?!Q9T{^@^G8Ykpr(nAii{9D%lE zuRO_^6(!XF@cmbRzx`XAzoygL!Wsbl?fwswznl{IXXgoVGP5(Yaj~&7v$L~u39$U@ zw16$Z<28mkNXY(`8`#|Z&+xx#fXG}NtifOa2>hFniKVq2;LkGxEPq0O(*Rq8?Et?S z@V~a^wMc9nJxokr&HvS!SLH*X3DDyYe*dr)_@ik5t8Rq;d+oQGj5<6*LO}f9F<)z6 zPt4H){Mu9_bq^;1$l(7^GVy=EdjIhEk3#%EE)=tWaAE@g=JZ+};s6U17dtSSg!?Pi zfBa~G06P!`*+0qujwMK8;^bs!ZD#VjBv@P>%>P!7O#duJ=2zq&HXti&ClJGHy;6{| z{M!%?E+8j>*?$P)Xa)v=|0lG$-K*pOk>7uW{=w=04*HMr=RXAg4~hBPVE1QgSpMkB z*E)iPLV)4!4HS zuU>G4fViKA{Tp0w9{O+a*B{%@l9&Jhe;-Mltg6Y5p*^sn2U%Rk`%PXF}Z@c8f2seg4OVh{fZ zkALUrpN#(6{r~+Y`d3GOEAapCZ>hh#eQ)I zr%s(ZwRGKwp7;D93WA`*|9kEUf)DW4--JEy{V`4QqLm+76uh_o#eF}}bIKR@J@c`b zw^m&}nO!z{!Ii5ny5Op-vaPEwykynnwyRcMe$}dD9`^86S7sMqvVLG7+24~s?bskV zr6&r$dUbksUfK_Wa8+MVEeIZ!1VQYeA8Qj{MR=OGxKlWEd=oPM^$tExI`AibKA~O{ z&j^A&>|gioqlO#=S3~y{g`xX+31aTwYm=aVF6@59{|ma*p!>Hf2u|q6g7sT3dD2$m zUw@>pm+A`N<-b)yux0&ZYw{w1#+&M{hB}{j>2Csote?E(@fnE5D?A&m3wOgis+7%w z;wcPzgSTEB1-Cb=LER&K>zF9``pO_UhxfFH-P`NzFzpF~B#b&#A_*%UWSNWv!KqlJKpLp^wiXD)0}gQSDjRKgb3PdZf#_9;k%R6L)( z=^(llM(JX`Drtik>;^rQvQOBCNM&R-wXpzjU{G@~3pf~L9n1p2R&0oa<3uM28ev;( ztVvQDC2^4`8z8)-CtJj8lNzge0}S@`?}VM8nv!9(eMmD@V8wHKIbwPyCkg^taQ6$P}%ejrUdtD-{ z3wk?0jb+f7(=a)WB`b4zxVoU{^U=tb@6N_Nb#XGKU(81%r9$^9Q~De|#Pu%=&_?^X z{!5>42G-iWeVC5XqbA?kwJ3OF3Ubas4(p5Bx0Mat$=NU5j`#@TmxxJ*leY;R?w zuLMz?{kKvR=#G&kh&=ia3iRyc9*;0Q(nKH3ZkP>(x4nXokx74^p?#n{L$~q_+(e3} z_`@zmA!XRyWc=77XZoWkh&Mf`8~?H5)@xh^zC!+SdP+`jr}$naBHc`xQQlX;w4ju& zCca7L!E<7iXcu_yquy4nIrXXs>q*CiHL&o!D!t-2PU3OVL6A>FD7>D^D~zLb9l$P~ z!43VvBzOoOoltgJp?G-n7JwDkh-Vc+*NBpYOR{*W5l2ahwr#`=Qaox#wRckNCK=M< z68TE&P(-#}c63%7^#@M@6QyXhp3_hrqRvMmYLxy#5>}&EB)2%;6<<$!Yd^%5(yd0v zu(D?j$yTK+@}VGP8v`n&QT; zA!+?&9CoNNLQE#%=js$An2aOYLRF=^UDf_%UQ8TCL1(C6soM;vSg6q!=t&a$MC2A{s75k&2D#$wK!SbMC_@vI{@S=osEt(9 z%}QGjY+y`{SI-_uc(4*TDwesPZ6LnxXFHK^P#2-$<5Xx-iPcX@UwMALDq-d8q781bO$G=3Ebo7BghX&Pe$f-L+7 z7238$SUv+G!axKeRZGj8?oyfp6)GxN3IIDZbAF9dqNavcE23S`%wNK z+^{HkK1Jb+G=`F9-&jT@3aicjQE%K77tVy}I$2o?dnMoW82dv+>!kw}&HfhU=b~tOn^f z&qH+>OB#_GgNT+qT-4)Z>8vsWv;Oz`_!j@Bvj>zbXVCu7#aH~__%D4dr@fu{!}AEdM_*H>Yu&&o>vYIOAh5_I@5=v=y7(lf4lkjS$&ik(c<$8b#jVBbf4@ z?4>?JoAzWc^AXH#Pxg8rd4M9X@)7!EPj-usVE=luSNI4*>B(;Ok#&mP<|Bx-C%ef< zXwRPPwLXIN>&afJNR)m+FW=u6nFyAtea1Cl*g6=S55_r?Rloku{B}C^GmGfe7a5XHlnI4ZY9tu28PvuF4T={*0hIfWs<$G9>kH~36 zta5!(HBR4RCAvKQ!M^0dvMA5#Ia(4$*%?GA5)Dt%x0ZMme~d6vQRO*Pd88;?r7{TS zECAuI_=A92XDf4`oOVQ)zO7VlU2+OmIU47PhIAl_DDhlnqH`7c<8a|q<(=2Xjj~4) ziPLwKaQlL*p^KA>pYkYDu>lbP^(pl`>sNFR^{b6i*HjzXGh9#{2uS+-gEFbdTDVwdkDvr6jbdv`hCq5z|yGR5;H zWGwo@rQ%V_NBc$DWyGrKdt6purqdrJs=SZQ(N)mpM96f7VDFuk$F(Oqt~`$`=P{j2 z-)Gp8XWk#AEAS}%#{=!^%9YCf{sLcf1@t5saky8_!WHo-%ar5aXYsQrcp`c97lmdA z%$Kc%W(FqI7QLZafeCCyu!x8{|AhMCBCuo+HZvG9uxZrUdjd;G_&CDeweHdZO5#8J@P>M~ppoilSB@}4CePjj0?3525#YjnU-cg=CG z$#Hd|w$fz7 zM<&woLJn=0L4Fqljs3yGWAm(#ky__jrQ4ga)3mmN<9Q1`naBt(SVwQF>ibG9II>Gq zdT(?>v$WA>`jFS4m8(p*qHGGBO8OL|<|ETNNu#N@P=_!=Fskm5%kZflQ}+5nzT7ZV zmxxRZuH1^}LEWNv^WuUBDcaLKg`EFtfEw$6!3n z-1j+!UsDRt2R}O;?krI+NM8sh3#ttw$Z=!X`Y3?(KYac}!?3L+GYF)su5_>9KzMY% z;Lym>6o$LvCMEFc1~!|S#MyP!aQFr+h8gx-6{x09SGDsxuLzzCy>%se-bAYVOukFA z*=G=vrIS)crcSBUNJG6DQ(?MPTZ~9Q1@rx3TlF)yBy3t;=f|$)RQ`=zjG>>jn!B-P zbuicyXl^DLD@m=t){IPQH7B(a-L7l~nD59)q_Pf!6)IE|KDR`Z&0z0*!dWm+qc^80 z5!D-&Su*MiUPjFxh>T_;>SYTeOKpNGopow39C>wk4h%Axyq?#%T%5{M(+z6b>uNb% zUDP{#LkgjRdUH|bR)y**8j{>xOLy=Z=|$6|MuU|`rCDGP_BMKR{6??K0Hda9t}T1b z7u^7#zVaGfFd?6&PRZDQM5gGRFjRxMybw3H9Bg?@p__+(Sp8uw zS)F2M&nKvLPW4NTkouzpYBJiQXD8{4c&PIx)2baw^wrVUOJ*mj|GIM4YsY0YrR$82 zY_xEw9hp(OD`mJfu#M^u=~tN9;u`*qy2P5TBzV5*KZu1do{~=)dlF*Xv|-L?|t=t zTdzB0L7J7;tBmNP%6(AnbyTSYyxttPPJ@TeFcR}yR;^bBGn$OHhQxk!s3jOO>N!cHi-dA zLu&0w>cGfj__ao@*{E7CXw-aOx5St332wYe9SOy15^24Wa?lFIGny{d<1ON#Zo^r6 z293Vdy!^qWku*yTKq9%hkqkHLJl)v#RzTa+OUN<_w^z5`rnt2M`wx(I`wteNd|)u+ zU>0yNcrsY}4c{hjW~dX8VNI{$%?XIsq+>Cmu=Q68wALNbTIV;FZE!8oZx0+AS_WU}t(J6+nY<|=6cmMOVoCnh=QuWcXc*^A0C z< zzY2@v7-D9}aa-_Sb->Y)`^)`D$Z{XtTWQ9<8~6I{9K~jMcQ$)C`zS;T<2n?@O&d>J z9|Qa^+Sp2PG<7*la=~FlF1?+P^Nxo)pK!0+c~R9}@h1tiKE)&5oBH;}Z6Q?Swh+A8 zw!S^Mp~i}Rps~6UreD?=6WOaT9zOzjbsSBhbDU1TZEBx!Mi-W&yK(e_7M~%fpH3IS zT|F8p^ET}Z7@XzHVw+npLj%~3=zNC#pK7J^Szcil(Froh#kSMjU#sqlUk+Z2;X6t9 zp&BW@XLMk3R8O%G@h0TJ{K9gP8au;Crkj*$KQf^(tH?1}skT*6qf)E3Ra9?1{UsT? zyw!t?p+$WgD{er-J$O=!Vdz!pZg2Wss>aOrffRYG664|Ya}amorBV7TNV&+eQo`~| z`kNvl{X7}^mR4J1RMD@i#KC!#IU%`Ep_7HP5>sgF3*b)+YDww7sywE5G>LD#e4IK3 zR?_5e<(-Hbd)PWylKvO*k;y%Kf~(bD75Ndpc5dNFm9>_eqgw^vRq_2r@h#|-9_i`@_^}lrwr&I$zOiSNv68t*`M&X?F9ST)kcXW0ao($@2fVazq^l8s*3EEC087 zwZ6k6-G83^NTJdCE~zU24&{hCJN2q`zNgo&`1`zCKj1NM{^OMYhomb1oyrk)exz5W z^JBes#XsTIx{F7;W}fnoSN@-ps{B7wj;Ql{Qwv;D{6 z?AIWd9LN^BdcXb06&uEa+ruC@QGDHvMkh?#QN<+t9gjHs6QI7TZO*5^2a;|B;IxW~ z$J8GHF}XOOR|_+rY_DefE}`e^@WMbn{Tax%$Cb7SIgBWK5s2B{JYA7yW1cn_L`$=CtB8}&xg zs5X+D@V*jP$e*B<{*SsdJ+TMB=^Qy!BD3);m^(iU^Zr|3qpyhvcm{c#6W3?cl19#p z>e;BKRNVgNt?^(*vJHEfy;{eD2^L zu7Zs{x?B%7Tn#e}pyR30*u2Wsa*t9{qmlku46A-)L%XNDiZ5>XJT3feFAR!aI0`9_ULe~}9H()9V7c*WMJPX<4nWNWclb+JVSrx>U&}Cg1rPlJwk>$5=w$yOdDA#i zH+Q%KeQ|RKjRbB77@;IL$HQ)F?8k-4zr(wmEFelh-t-3(gikfP{}kOr3c8oyPr9z- z`?+Orun__egC4^z!|^8S<@xN|7V&9=b-r4+i<0y6E*b+xE~*m{3y4A_}PtONd*)kRI_W+$+RWJW~ zfOXYYF6(H0BG0ke*lp^BrU2$OMVfoYDK>9ZyWl7qll@yzapuLY=~)vBQ%21A=K65u z=6d>LWWUz-A@M^tew7Ay<7_oR?=_$LSIU!>DaxzNp?z0DI|;Dl_7}FvQW;-EBusxu z=9yy)5#brSlM(3&MOC}W>8c|6BqiIhGe3S z32I3WPjha3#^7xDX}#4fX4Ltv?6aHqDwx(NpgiS0kow1MOIk;;1;;u*tXgCV;r=m= zdrOS{WWZt8vwl)`N{yIzuvl~?3YQH4TZ_+V*o%m)`rsvrwu*76P264Lmg!;rPgV1Bx zm*UP<%$J_yIr~`G+|vGh|1<9}TaF~g>A{o_7fH5)_)ME> z+BoiG@l(%Fg8?9en4Rt;qCXM+LwSgZ?(l0O6c0B=DvMVjmHn? znG^1+*2>ir>X4CbH#SRRoUI#g6jkbMZ%2C|cpDkdL#A#+F^Tuuta`>Plg(GzdwAjo z-l47A_f^xMF(y=P{k|Hd2Usg@6{q-a62n{v=&V9gjMg=$=yhivOh`4`v#UkE!M9=< zZ7;`doMND0!fl+H<7mn};?74_w05u}Sk)5*k2Lchtn+~#a z->kc-PCQ&H(}R{)e86_b%AE-jf)15>R3R^nh{V=6LtP!mj!UM(?l@^}*e&+g zY`!yj9o2C&N!rt;)U$n|KUi_XYvdbp+Jf^O_1biD$i}jCwU~hir+<;1ReLo2EX&un zCSODuel2VAHAQ&olU4WnwFvhz6WpwRxJ0HLiJv_2KxG39Cirhp;`fR`QG1jN{2N-2~ZkD1nN1DkP z9xp>poUKusdu15r#8jy{5)Yq)<6(I=erwpzDfh7bA2Om!C!kyIIdLQaw%?C2ZPPOy zg|~6_C&0%VSWgGGwE=gavSR0>3=Ge%?=7p0 z;;{hTxx|W{PMpA#1%PeGku6SP%3#n(f-&>N+$qe8oyANa1P{0ab{4Z@&vcUqA%2u! z&vaZMl;71e3FyxD=gyK;?5N3v*R*qtcRdTW@cCxRXN#ffS(eWQ2GtY!94h&&lYHRY zG(qKav<9Pvc=X&|ib}uO()HY(3c6TsfB7pF^IG!uzr-MVmfQbQgX#&%-BdJ}OIOD= zpjK>H^*a7I1L!#)0i?M*jms^Io}LD+4N*Psg~s7-G}ZLcehgr0eOJ>DRC z&TX%9zRa-n%=5`9bFSI!eCt~ywA*y5ft2|Y!w36)od?*sDt}gc=lfD$8o3c|Bg6q_ zZw056DQpXuPlKd$UM`o0d(AwV-f8ZXMjJ?`CprYy8bEVv4Hh8JWY|XED>E15t1r09H$R+<-2xU z5?n-0QAvDgMxw+%vkQwQyJo&o#W2G8ju~v7pQ?zYTcZH{&;s0Ffb|i_C`VXrDt5dW zbF;9dz||aJCeEY9k)g13#KXMFs=06dHFbKJa1`I(rHDj4Q!h8*t;ofl5E+WaZ8`32I6Dvdf=u(s>lT+8X7vEpZ*0hx}qfmGyd- z62$P$>=WP#B=YDgos+k!X(@;%>!USW;!J(sAamO6=PzdFMzCu_am>D^4Bl>hho z_!j?0`v2$O-Fz6DDrYtH`2Rz5iVR{Qsu2K2Bo0Q#N8e_7N;dPx=@i!I1Q%TYLnO_oNs22#U~?KGsJNN>6&ZkI)W1>EnHb zmgq^Z@)4S^C%wW)P=cQHaf(c06t8x^zMaI?_?fhDQ2p5?onP2O6)!bgGiPL$46OcC z0_Vex$ykzNOinNM5gUguu>x^aC{UDkFx~7a73geHU1u-t&uh!W3T?r+IE8%ag%I+I z%+7OF@?+3`0m29_Gk&oNcoHl3c?hBi;^mvC^jevm%euB5@wB4im3y6Q&c-zWacFEt zG7_&`z4^I@o^F1(y${^{@4QER!H>)f4%_M(euW7KJu%Imd`zCsl9nw2SogqL=|()I ziwew~HXF0PQf2f!^@;PQdScyTXBCy_Ex4Y=mCwsv8hNqSPhFi{{nD+--1XVrOF}HJ z?N$Y>NCb~9WWQnpGby+97&TkhK1@EVTa;hpDNH|CzB7jq#S$$8%q(2qGi|>=57>0zZW1 zlHhUlt0qIiamcmLjuTb0;|cREaHHEu-^Iu9h1b$YKw&tkx~mqxVplCxZSAw_b_GY= zJq7iEPg>~CvK`f6f8N+%E9(R+%gD3%#l$U1&w-|`dhyk{Uq4wAOe-^g?i1MTBoK!u z%)xh%rtWe{%)c9BT9j+ltfuj6H1YvkrwDtZ+c&%I?M3>9$LZW;~vY zmGLTgg4&xYUw!NfA0-!KmIehGUuP!NP#20)W~^!38s7x z{^xY&d$VI_-%wq`Tj>ba-tcSR3qO(f*pqln{+-qynY_oIQAOdpJr~<^(4Nce zxwk#{wdVo$)G#wLxz54|+w;Np+-%Py?Rl&{9fgxEtSJRw=HT-5_}RT{&-^^ip}A`z zhr(pttNR3Wk5Yq$AjVW3+D<=5bGVJIW_E@!)u(k&979Ub60V(pwlk>_i$g$+3IhYt*)7^t~pzsFHQKnW%dppbVlCS z76)&Dhpq6y`SxKQ$V4K>$h0#np%<3!QlUekx?Ar73tXqaHmPC>cy{kBVmA+F|u5=g$D`9Wv zAiWk<(%XRY`P$tmnGVc-3US9(JM7xOsJD8{zG|Ra`U^REvYqwxn`~8YI{>g&^sJfF zOG$M*++kZq>WGl0OD&dSl8otFGRA-v)KV;NJgzQZCc~DmBXebmj4H%;Vn*dVz_Uk* zie?YB;q)k!WN24Ub63wG|hpfu!$UI0S7~M9i9ao3{D-)0uF{oJD3F=Os%1Bx{k@yEa1|Z z!#aEm09!%(U(cJhlSb>`?cA4Evyu)MZE^OCRj#D-BZ9*%T$&_fIZNm1KcJ4nYF3g` z?kIo{&H|*A$gx`c6owmtSVZFD6lqK~V-3lCf+T%|16(G+TL|xrVZ)sPlbjig^>^KM zfxZyso3H^pLx~OMds!()#sV7OpUKGa#TkAB=k=G^5*hbqYH=*d`Z-Qa8tZAvy6+ZW zqqU0jWWJm*=no#a*_{W|oh~1RBxas+)THA}h`L~Q2x{SX3;e}Yrt7UMReICe$GB!1 zZ)(125qbU1Q?;8i*7B0t@Hzc8oeuq`)3%JY5u95Vc$10aR1$|6kjA(iOfJ3I&k8rS z%$R;8oYChVwMQXeD#5yO8oZi*f34~{oZh0w zXdkTVY7}-scWG6I5yTPMsI;o3DY!jclfI2i!{?-Lx4aC*mGK8F-N6qZCA=&hp$U>D z0AD4n^sPMYB#XnckA~bSJ!f&`swU$X6=XO~C_~g= zeeP=jr)wy3Ua%gQfcim1(zzAzQZb{GzZRl0I)(r?JBnPB5UPF6jhk; ztynz1FqlYp%db3cgT)T;Ze5NpXMxe1RgUnSyyxPPp<-i8M{?IVb5fYneMfg}Ly>c! z#-0y~Z_?#wt%8&7@Yec}_35a?9cP>X*cE?RJ@rY*siW5RbDzY%acc|zBOaeAJm&sZ zNSZz83pqi$-M@L|#UXl| zc861Rf@0g_)6i>O3$xRLT2e}=H1X!Ry_>F2;q?{yK2ziq)RK0~SNg!l^S7Fg@H%oL z!r*WpraRJ2)L-@u?f|Yo*Y%xnCPDzi?Dd$W_CXK4VNftz!(;pnVEA;V6?wXX%d_p& zZT#de!ip|}f)g9MNzW&~X*F?wX&tT)9ZJQf3Z~R_)LR5!nsSUEP~^z8mf@2WoMH^F zq$hN<<##i#m=Mj)lM7upKElRKFb`hHvVpuz6jR2lnRvmp3EdLh;WD^=ZgPU*lcJ+rGYiI)Tyb6tOmbRC0by3VNKbp161oUXr?(0%DTI$G$i&Z@}ZPm3-C6Lh1_&7#W?i^t|T z)DVzJy?q}V?%XC6ulpZ>K_#jmWG;ulSr->7~8%-gnnw%Fj`)s`tR^?{DkCd=2VcE6N{>oSeGrU2yb@K*X zjUMxF#`glsZxcB19s=uAFL&>^Mk=3H^585jY^#3WrB<-yQs?K{fI{Fp>bWG?wdait zlwE#Z+SBJrJFfJdnl4&b9{E=q?)6tr-diJS_p`PPh8bC(Mg?Y{5ova?UKK81p^HG{ zi)t15lppgn@T;QqKU{<{%})y)K>NctBd2FkAD6YVNqUi=;o2h%!}R0iO+Uc{XMaYG z7|pz1RYW`a{4SJ$zAbR2bGwkz9}?+e*qzK%pCl!>a-SmH`ZSMeK`kj|?lqcyhN#c} zrn~^nS^$2Qr3;%eqBnUdPE-0hBF*L5=Xv#&82AG5{!)B7@o{D~ zLF>N=4RljlUnD-rN=zmDlJe|+zqY%F!anz!yn-TaQM1uIT=RjYlh<^i%c>r_+*a{? z#4eqnDt;~Um|*2a`C4S8?-T5=%TxMOR55Hzvidquj$MyviE+fZSjofkGqWFp znBHmF#0|Gn!tM3p!*g5@$Z?0#OG|WJxWM&^Ic}wd+v~%5+E98~iH-}G=olc!t(0(k zeYn8&fE;%yeQb%Y3m3RPF~_ZxaC?2Y!1aI?*!O*C@8{B%+;Z^~N$+w>z(=X1Sd7?i zeCn&(cjgS7x;bEAd4A86%e!N~ygm1x_xdoqi?VF7H_U!Ya6Ex{nEi|(i@7>4uJ0pd zQ*V$iX5U9W#=z`uUY`ws(ie7fR$T{6e+i0p z;EuZ4NI16u8+zv_SIXx6p7kwukK$>usD4;UudwD~J%X@P+{X!0#CubVYfO5)LzVt} z)GG~=$1ACeJDu-_dp%tJ9^vCFrDyYc-5W7d);i(vN(Czu~Cn18}-<}H(MK$=|x z&r8+5n|!|MpVjFB)QN*%Ly(K@yM=8J0m4!_CN`+LONP?PauNQ@hVp$d&gYJFzl?rA zg1dKoJ^$3Lr-BRA(~?|06|{P$U!w|YcSpOT?-_LuTBCJ`r~N-&+6wMQ+qJzVxwcnu zo9avL7OQsM`VQ@iy5DoSdb~(w?et~+xm%WkyOrhI%aU9@6m<3Y#;khu2FxXOm4Bo4 zJx}{DUD^unM%&fHl3YC$w41%ChgP4fcElJ9EVek)&6KoQr2HPR*6$!QEvO}>|0BE=d^2$x6kiPAp_MkQ`<+KOZ3gHr6bk+Q zC0hY!zlTQl2Oe>T&||j;)wfeZpLLnb@Cbbb8yxb>4xHH%)4_4!%*S#M&%SR(3E=k( z&6+fpvo>IVku4;KQ|Luef$ysV7>Q(BP)l-$(!(j-rvmK<1)89i#U9!IOZhsDR?Pg|OUJdq|P*a5N z+re)m4UJEJkB0qwdBw%O7?SxquwSaSpZR#+G*NapSi0TJW(7-ncI~OO>IlD-a+^YV z`GXrq0%i!h0~g)VRZ6KH#yilsQQVz7r1A4BQw*qh>E0B+&#=69Adhh+DDHi830)%Q zOtT2DqiZg_)T4AsI`}d>uIIwbL;E$BbQ{f=@?osMAkMkuK0jtNvD!{<$CV#D6)tS= z-d`7DY#)nMrkJ`F%6505Y=T@zbilc|)p3hU^#8$*u`#ya_WK_%Eg{?{P` z=0LbIN&0()WKNy-2LC_=@ht*}JETiVx!h~P$)qt?;rrUVCF}6U%dz#FC&KfA<_JN89sr`^vLAQN}$%IC!Z)n`)6EFkW9;nkUh9CYW;+v5%C&YZX9Su%IDEXqeg-v6cPZQ1Fs~_P z@IvM~*P=d=-3nw2Tj`0kpvQX~bPP}HkSBq!zi7wjA!l2Ei+d^-+0_&%i>ONTh-Kg` z?&;kv!44mI!WA&fcc*n}f1ylUkzGwa9qq$&+H(_*kZU?iI!_Abn4u=ePQN#b> zhCS7Pbq0|>*unixwZDuZnj-An9XV=~Z$Rm};r0#^ofAeD z;?ZBNwSLBXAj+H3;maB2G=h&DTmzi#h1@(K%IZKu!-@2J5~X>XyFUsS zT=z%)59P@Ea)}}rfm0XP{}}^`1H9(m|`mB01 zT}*H*#<9m;{A^dX`1wso=~FyZALV_D@-DHw)Bj3deFyniXuMf+7$UzU#l<>0&DP}A z8aA3wokg?wp%6cq34i8Wbms10b}KUVzaX+3%TBLqc1PD+RPHkJtK8+h*~(j?SEa)Z z{NiG7Uaft249z@k78maB9o==8tFUWBC{K_$+MFu&;YdPsh6 zRXtXbU-j6RH=M8L)!L88(9CtSIG-y&;m_PL59jw?E{43(T0?%7yOuZQ9>A-W@)*)> zM_w6cog#0RZlsDxb$g8!E$I#3(?zLRu&-~zjRqi`f?gPoMa=9l? zjib@n=Vr^;pB-Yf~n*(-6})~j_0G&?Mk>cZ9v z>8%GDBTWoOw*$`=ymEGD@4NSvXQ>*`=25Jdy$T-QB_4V`4-FL=b(ZKAw=LFIq;;qm z+C$)7F{eCphK6S`g-7*?H-|eoRkvb%Z{jlwnOmfv zy->tX3fh3J4?@9Z9`11!DsUAk;o7=&985#=-I7Dq295KD|Casd29#L4&lC-DclncEdrpID;IeRf-xJ2<}*UPkitbfQ6eN&2m0sFh#7 zz7|Y>frc*b4sYhp?(-?d&GcC+>%qGT`Lbs0eQy2~24g)(Jh4ZMWb9pN=aHSj&ZSa0 z_BY*?UB-lm-5Iu(XgBsH`6SCg+fG4K>@-5;f;F)jrK`ofuFt~H3+)?bW~2CrBC}O_ zlE_|tu`Ul8t=coak)ZOZuk-z6x<6DpmyreT7z=H_Gq_>@;9GF~e(1Go&Su#{UuTH^ zi5%cSzupwL6?bciI9=}MbAE543)Q@D>T<~DzVHDQ*BZmhO$%yC>GNR8e&r^8KB3N@ z&>UjQ+@%6I8K;v5tvbvM)ZP* znN%m+Ykq912lVOS-%W4S`qs+KgV3R5>T#u#AE1(%x+l|uT2lINh^(*J^NMb+RrMpA z?grt3*cOt_y?ZhZEdwiY8LxmuHq1V=$KVWqd)b=T;li3?*1WMUmhjaZ%eS$Rs_0_SaL}dLp=XJH8M63S$_#5={wC-Iw8PqsMbG10( z?v$`CfcvK3g4si0)C6&U*cO(Z?QlWci9sfbU9Cbf7$AOH@mT5^?Z`rgH|bb*I26(c z19a;&=Z892m~IB3>jh;1x2g2QLx80?W3j>c96|4;>?Bw_uBV(2BPTb*KL;|)tbf_% zzIUPpx|e@?0BQD*l?F7)<6m{INc`n=|fjU&j zg{#(4Ku69F`NfwbREsel)PhxR$uK`7`H_Ohr;uK>SeQ-_^(z)?8}aq-&}_gID}{wo zJQ}pt(UdeTs3qybVYAa4!?sE@Qleq|=ZBGj2;+#!-M)bI7mVlat~G;0!T%_{O|cfq zfsjo!(fBH0llw^^lgP~p+H}{k~}noNbLhc@`8bB|Bac z;*MpfInja_=gvO|8xQP3Vz9YK0SHl0`ONX0RP+q@Vgg) zujrq@+|dQ#k5~Zy@&(|ZSOEUR1>p68`T03$0rCeg*ZCxS@&OJ1>oI*pGk7dX7rXei*Xqn3 z*l;uPb_&9lDr&<^qFsB6PJM@-U6Sbuls6{}2Y{Z=sNsLI2se$(sZ)ruee_bXcp_OC z;Dl3JDbxv8JFeiz5RF9|%m2gbc7K*f@wHBeW|6;c=Yl?N`SDHNxHY*>GB^nq+>As5 z`b{n%yZUg>Pa}t=#TrQ4_@*_~w-f#Zv|A@bOKVf7@MeAHp?Xz1{8j_2Q}@1psT?!E zQ{nG}Z`%@dh2;w|qBSomvgi5s>@r-dq_41yp)x`==UHp7pB2wr$RVCD;O%)!J7R**iI>Yr7B7$G?RimfCR~^orF&i!?9FvZk(`-slT>?6 zhl*3+d7D%Mtwn!cJX}sj@o)ui&x3+9T>Y|;9xL7RU_q}(n&a=TN0fb;>L0g->-a^H z6v-8-%WtjMRERuS_gOMyLKu8O{63D1;`i~qJ--Uhurs(2ze@M~TF|$j!nw%i*P)zu z%658Gv8!1BOMF~OZt-yyZ_kHs&uLuM%^0pcWGG6R45O}B^JI=+3C5uRrG@E7=@V3;cHtOk zDbU=4s(x4|-}i8IzWl$V^Xi<=sk3-ZCmoM9+y9+en6~>Zl49#7DvfW>nXzBukSkM5 zRaV9Y8ioDWJ&i2s1Yd!Em~AD+AIaZF(5`23D-zSQX8YMSq`K2N4bBa^-vqN+xnBZs zD?&v(R_*s$ze*X=rh_TX(L5WP#c8f?-Hoo6JLad=A51{uYsT*r#pEFc!AFz{hFvB_ z%u_8L1@dcD19o=j>qhUNw6pyzaF{)5Ht8q*YoxvYI@;eb+W+X%X6z}m{lB68Oz!c9 z%FJS#)!g2RK8fLE*eql}xS<(bzzW}gt9*9~>tNhSzgovngx1Kci+QSj}(E>}BaSTT`90NIphWdAyaw6VF$~j-U+G-4T>) z5wup3mv3G~TBEXZkIfVsjHzeFT$h5!muzJ{rzhJErYm~7oc0i6hxA5$LU~CuJw%6S5iGJ4paN;ZL_LEX^wc*!J=^wsa1O`t-#zcNp>xkQT z-E&WIUPJzq{DN;v=C){>pSyFOY-ke2Bf)_Ps+=u*FT{O6;fze1D(3qKPbS>z@R%0V zlG4}6R5+YG2*UcALOmS>6H{10+CB3wtp;oz7iOr_pDp)4>Ed&+~>(#@kfvZF=ap)f~?#nvID%Px>f$ zhv!D?sc@@t=xMy&nzbK|1ejq{d-u`kwa|&%N>5)$kdH4V==3^KaPZF4340q*3t&I^ zw#s@2P?hye-b{#|r3|)A?u!(BhOOp>id4E4>G4Hie*CM9MWv^#>*jmC3*$exz_&&C znLaV0Moay!uZp%>Q9~oE+9Gp}rR!(PqkUoW`7Fuf6Y zm_AP^w}PI%puj`7U#N)I;ZH5_4b%704M1Jq?gmLXu^i~+U$AoB`r5JV^hKiP%Q`@s z?&LDKfdvKfe3!cDYe)9Gito3P(=)UnEIC;KJmEKa-=Vs<{tcq(ZE(I;dD*Ee@@k(_ z_1r1EsP&Rrh)W%!(ov{#e-#&T#TXiq8QY zrr&a45_vd)|U7l^ov!`6V%03fv`U~6Q%dXYq=NuHy9!Gtr==8!VH%{&@vQV-NeuukhFK6)K_&$fSoS3g&Ae9BO7g` zcG6nliKOc{?OR|Fu zlCyO9Xx{pBoJ=<9*X~~X0}V)F$tJXt^f@kTzX4SqM|#~izvAH}Pe=#oPv3&Ymy;j8l^QoUK5 zc9^!;EpSAFPC>Qyp)Y1{FcHefQd;^ZI8)m(wlHG5@y!CjR?wbD@xBuq;n1@;kvkb% z1dzKJ-%Ny2eGO!Zy@lAipBFbXu9n?D2oc^flr!Yc821PJt_ws#=YvkeSHKRxSVf~h z%WN;;M=CE$A4(dQDcl`Xrv5!w8NH214?<#Ye`yQWk$dpCJ@uz0tk zvV+@=R}5wE0l<*u?PoK1242Wr&}hBasE3{R@y0!Vzh3Tiq98M)!_j2U|_3a@e8vyakR;y=JNex zr_4t7GgnN~EE1}_&0zcOaQ);K420+DyD(Au1=pIHGrLwKZmW`}nYAU6(@b-j4Bq0K zR_?NsZg1TpGk6b#2I_XT9jFj z0bn=RhNoT*_L|{yruDWv1N}7t16GTSE!#M|y`N=|>B0?2YVW zt?VR4w7hV)IJgN~xjVzbKR>hzYDw;lAcN*8=S_Q!z^dcu(JNO$Km#bhWcD8rT+7De z$9ea;Dpj*j5ZPI!@HpKAv^y%*Zt162B`d&TPz!$it3YVM^46Yekm4Lze*R47!B&#~ z3&|}Ss`M6{vg*L2w!Rprw^Lkx2i9Vp@d|zke(RHf6K;|2e2PFRH%&alMd_|TPksh* zr_8C6{`t3bxd*&9XMfg;t>=4aqCPVwdhdgZZ9>kAZ~JPcJ>6Qqr%Sd`WgF$&DOVM5 z^XdTuOYkeJyUuhKm0#35tLDg)R^g0Naeuh_-$CU4HF<~pssRJtXC#P9=d*ehKSlDN z#O%%=+~>~`&inSMtW3{JEtzVx6-QP&QUj(H6zc2A-Gw92_Ix|9BV_`1i z5-4n|R8H1^g_qsMm3`H~;v)NZsx5th|4rO{rt&ie{dnz2H~w{i#Lw{jMA_^sq*95X6p&&0&74P%`cgl{(vRc#*pyAodZ0m|>986Stk|F_5m|9XvVM{uvD zOCY$L_3G{1q8EBa_cFhs5^SM-I&Y)3851L!9L3zl4@wGl_gMXS^g+sv+e#W<#dY9M zNzqzeN^}_cTi>Brm*~>?Dm-rC(YQ18pP9Oqa`SF`kh-lhObcpBp5mj5T#`}6<{y6$ zj}P%Y9^K_p!3B6!QgarMhvz(U6xlL9x+qC<++kanp8OL1 zy;VVA+lyNSIil`(Ok#)YNj#?D@?R@jZCTwFADNS#MRZF+lqxyBtOOSj{-fIFDDp^u zFtfS-C^&C@i(+lR7`Ti-^Es8cexM(9mEveZ|FDzwx{}i+P0{@T# zUr#Y$rH^pFa;=(c(Preu&oZfqBz{@ zzI0vcxN}2nyv%XtW6OJe!1ivu-C}*`wa|&O?>Ppzr*Bt91ya^=Ve^O@Z$P1+x&=)O zvBU*XNKO)_TZ`=Y4z=T*@7Gkk|_fwCX)xZ!w)97HKV+{}Kcm)SYy zR)%yZ5b@CU(VVZAFhA7)9Db7X;X?KCBhs^JTcx$}fZcq|0?^UA?0I2&CJ5ZveipBl z$vGZhvRw<#U&Ld2E@{!4O?3ck^K-d-^yn(JV^Gh|+eA6n{a&lvUyFQ|$$w}-{s>)& zF*`2hurb0BM>LKIXK^Q+gW!J@d=I-K>^&{zI&im?87-<*vUd?{>f5O+!nQK{-^Eps z-xeZKb7sv`@Y{mFi5I(uJn{|UE>##OZRVl5-wyrdiSlwXNwJbqoG3Ib?4Jl--%gD%r$x zXe7>#>BF)67!pr8TW0fjXUF>Ojw-SSob28t@q~njM6>hvYUApE>x4c;cJFbUSHloxUGlX`P8$aXB;3GlxeGjg09q`z7?L zSYEI5{Q`x~t|YBr@aQo2sEnNI;Za*r2SeseNt|3QK-nWG@KE+F3Lar?Vo$rT@}I^} zdLuxSj_PI-`x#|tzod-pS3Huj%ODVEzb4!lrcW38qk*^&0k|^dHzbT74Me|A@O+Z( zo~tmb)_SuWi29#5dmw_(R!Ojnz$Ljid#+N|(=7HJV*K4Ffj~!_6(tZJc62I?Jbw3Dwy8Rev)OFbD3)lkb9RBoB z`ToWl{ItK?yJI}}az zjcxmkfAU=zhq;($9Lnfg;4K-8F#V(`{SHNI;y7LcQ>{NB!Sv(w$#GYB+!k|dY{_%& z6rHsg!v9X**4>~_3u;ML5l^*HUnpNH%0f*)0cF$YzOe^TxvJ@Ne^|@b(?Y}9XP`OY zs^LJaKfD9jTL10;m+$S{|4Ps1BYMIK!DVA*~^*av0tviI?Dy09^9{ZSIQ-P=3% zvK-)J@Q2dh7|uLC=b4c&hMBcpgxi#cU2WKzQLdw8jI;uOMFDmpbSX~n$=+HoF-rS& z>2Y~)iEoxxjZTSMH-;SQ_>Iy}I)>##>?aAS?AZ*eN{RbD7JfDU&(zY_d2qu%_8m9b zSkpwI5=_UZsBfrm^Icb*+YISfE&W*wrvJ>+pS@uE-AYft%+u^Xb{Ie2*W#`nh%QZ!flep2`CGA4nOj3J;YCRI(GG&{y52 zio5mr>Q)oNop4$;(uFU-iu}DM=caWD2F?VKE?UdbgX&0po8Eq0s|5$EJn)&PYh?RA z6x|+$tALbpaZfq}n6nzP%=`+_U#V!forZOHV^D=glexZC+exIyNn{(TVfu3s)`CJ6 z6)ROPJ5lyEO#enY-6C=wxj(GdDyOBtRwi$^4e&bv1M^ad&8w>0)lT*7(O3-zXo_>= zcg?oT+PmCiZX&uDx#$WeB*O8FGs1*7;_ z8O48)IsG(%^fT&ajAgE_d+2xWgFe-D+Zz$RcbypeqOx05>O66Ggvi|>*N(rCg&6Es zLUEQaw^27y%jZ0<+(EnFr=N0t^L`I(KEZWAg*4QqB6uG^ZN)`0I*DMix0052ajc{z z99@$bC9N>s5A=SAUbCNa$-WOETl-|ZT*1BLuK;gA<-1|-A1dF|ze{CS`}rZNCP=mV zEw6>7mMN*u6Dh-fd#c8LQ$O|@iZRHBoWb6){mI8lqns#P!h8_z;rt|)Bc%eaziBnn zJfN?+@6&rtBLNqi&!UZnOqZF1cZKMu2tGB%wKFgnfs z8X!}wl?T2mwqFC(&vUIJjUIB#(df7J#%)g{#BH74Nw(kSs`5il=WhH~RJDNNp6=G7 zn1{Saqp=h?Y_pV^|J)nC$Aw|!UG!d3Tlc_9M;Pi$uMX3%AS?U8*X45pFcMi1F|pef z;=o`xnL#Xj zf8N)9t(bQF_gV1k^YEX* z9T6^~;`if}_gEdp)bjN8+UcQxsWeoxbv zx0rNkyGls^iy92pn}f-ij8CK9NS=2CTOCi(W3X>YUt2^6`$Ix=iW?kg^fv}lhWKRD zev+t1F{lQBwX-0<0n%V~bTDZojXE9nMXsMYAA)@%>u0;)ZXx|W@)XGPM!t3qmuY*T zsf_*ve?96@Q3rCgIz(3|K=nTU$J2iePa;p(QR8)9o10NBqb5CN$eVA zg5;`xOkq@JNE3rv{dw4)6;IHEW*k~lN%ugQyc)brWa;N2R~V-+?LMpW$|T|?Wg6^l z(%!PCjowCV3Z)j$mO!_`Z{5j)HF}ZW4@zp~@6=rqJUVmLWbXPcil;xP-*)d7#{^=| zS*|ey!Wy;gNH>12i)%gR5h`1q8{iPmENS zL{|CJhq%hFIR?6Z;t4eT8%l_BkNSlyTsKA*n4Z81)tfTL^Pp#rpFtagO~BO zRI=7xV0)LxS!X!vptd3ww)ng$=_u|b6=h2S*iXSm*)oDCmd?6rO0vZ2`vGth2Ae2d zPV(04)tSR53(92)Us6wxs|SBy`sl_@mv?YZUM{V<-+6~DFN^x+a-ZwU6_j$nyimD& z&dF=#-bY^SJ6*@wcMDLL^TYI~=!m;Btz*LE0m zn(z~4oC7RwooqXS+R(;oj#;WoZ)-KvsXqM@CpXe?;p-ZrTH|ywt=n%Z4|i$Nb6HYo zI~i@V7+!WxYbBYpeXKEE{$9I#Z>ePCJlFa2x429uaT%2lJ(HVjhZswB7{XVov>qub z=$=Q1lfcjv+in#b)<9{U2f~_ZfutMAm^CgZV+#P&JnC59%iv4j8vq7X2&Z zWe}?CKi_laOJVqD%KNUAkuywEG5JIR)_^5#QGl z{|dyXJ_#53FdizA`)c@27NC}teift?t2C;^8_9^>ia=!@4}IpptuUEe&93iq@DzgV z&RmX&v^#SigGtE`h^kLMS7Vq>z~*I^{g5ljJB!&*m6(kRW(A$nV*zHx>*^?M^`oI` zr&FCw{46>B8kHNl(ZRd{;kKQmqxNx7?!E+IccW{(*{fUMhjr^aUIa7lRr05f_<=sc zI<2yr!u>+qFXkB%CJ(}kOn)nr?fuQw!K$O2P1l+i#{+Fh!dVN>)75YJblO(<)~IRp z+Y2S1V1(aoFh@4b_*76ghOB21WTm`b6bgA{tGqnWF7A!7JANsr8(!XeCUm#6*Z%+S zo#3NtFCeGG*hJq2pIn?vsklUQos!loNqtH-pDTwM ztCYp1GM|4S5&Pj=O`bapQ`Iq0@+mw_s9B5b|&F!ijNps|j`3IPE z)xTQ@3GF=QQL-ZJ?|w!)(%Zq;#RAa(6_+n<0O4(Pc(@(H!-I8riVM#Gyg#qF&PiJU zK2GurDEciKeimEBqPKogrS+f!IOSk|FX+TB*OAKvZOfd$k+I_0p+?cZiLm&C=fub6 z#K-5vH_eG}o)bUJ$Jy%={V02g1LWl&J~#b{+36E=(~q2;e$?D_E@x2#=Jb#8>HNkK zx8EcgAJtg<=JDg_#7~$LKXFd{q&e}EeH5K=jt&XGh@UYh{_r{RGv~z5a&gwmjb0_=i!}%q^!VP)@sp>YGdulUmtNqX zHz&>!gIWA>cwja?_V@vG%Rk@ZdHb+aF7%?k=Em9dw)CR>3ml+`v)L?!BF<*=toX$) z-Yx$U19an;TD-`A*_`~3ofE&@#dH3zaM6PQ$N6|c@9_@sn{dz0l>~WRlHk5uW*a$Yv(pp6FfoyAz$9SPJqxdiToBwA~)57I+ zh4Xa1%Q$7Y!tlU2lWwD|rr)(@ZTq$t%7|X$7|?ebhrsVXHcmbfAQgTRFRg;}hP1Q!+kCSiw(VpfH<}|G!DleO_*#|d=mWHBQST%aLiVICV zM5`Kayvxlw;CJhbNU5Z4iqpP87_g+H`C+5kdNME_py=?<*O1dGA<~xC9NAMWn{?UY zm2BDo@My*EP_ghxITaH``czBDo@Z?aIJKS59m;pu*Z6-L>0x#q&nSC3&ty#VoH%<1 zVWZH8ll)8~{KBuTO#OJLA#B@IGlZH=WomxfTq9?gK1;}2tJ;fLFc_>I50ry&9Gr57 z+nKD`GEUXhD~)H zk$h6^D85A$-MlWbwIBv5Z0%bCyB}a;i{x#JNH=Zg>FtX3D;B5kAZ)&NlT9a#5VNs& z0_tDR1%|w9t#|Pp2ZK%k%W9lS`6Sodr``)a`yRcd3hx6ptprOAO$@`? z`vFKF^L46G&#>4U8g#5PTsx1-}?V?b|zqQ6;eQ)I`>9i>s{U)-vYi!O-VxXL z*BA)CE`WSAD0D19q!e~V9ZQs;lZ_WZwo>A$u{mE5rq+PjJuUw$>dLgKO* z{;HU0evMym&nKW`!{a@|oQ|VU3LcZX`;j8_glbMN!b*LstnzkeVZUjU+QlTs%75+mgtOW-S?hW z-X9HGZldf41%>p|@8Mb6*%leR;QL0v9c>YHkJ_T3w8h)D))t>WEv~i2{~EVk+5yHn z=2WC>TbxPMx{36%oB4rvr7b>HPVM_tZ&6^m`F#&WeilG$Z-bxrvps73<=Tt>xb+yLXZFm5-HT+q*4=o@>FtiM zGEmzU?(T;B*C)k2!HLa|jEs&Lqa%Q@%9Aifo-u59k2jbj;}>q>U)MkYO(yRGW`|WK z#U(_wx7dKT{_=kH3leSK!4H~}JMDvM!5u_z-X&k$yj!1g^OyEXe}>IV_E~f+Kue1SCR9g@Qt+y0CyH_6gqOUc76Wp>f+ZPzO zAJYbf7H7ZZm(B8t`}mISsEl~PTsFi?6ZZp6AJEV5_*qiV9^?c3AwHh|0Q*r_6OBP^ zDoy7#(8%W3(2*4&ML+LyTIXzDGs7KCh{Zs+oIQ-kueHy4DO>uM`c&LF`vb@$A!>I> zqHM(3>UZLn)46PdDHBGd&HMA<9U%tZt-KeAPjhY(e1_}PgWgX zl*S^hQ5o8TJ&!5vq4H4OvZTw|BSZ}L4UdX7jE=EP5&JOj{jOTt11?s>-`o;mj}g{a zwtX_^DX}IwYLlkdQ=;d_LSAJyI-1|t8$!y?tv!}|o@<-aQq(_Ts0 z`SLWdKCj&jwl}ABw10bo`8nGiSCq8KVy#>^dzd{fZH)xkPwBR+UO-rAH_i)+*)}iM zhv&|+isn=Flk9xrF3ouio8!Eb(dNXI=PF${YXOpMMIYK?i_ zXe>GeoHfv?oURbV30zI3$q|X{XHcyabf+|JqkCo`E*{T~jF!tV=1hN6Wg2LAY1a?Y zCjUcTi-X;ao$?oB=OKAJ(;ykfJYd4{fwO=)VuSnr>P-bpN9l+*7m(>4ncF>tHzcR1 z&N5c<=@am`k)ir`%q+|f57-2w-ovm$X7Tc(r;}aZTP5)R1+L$2RW{vm|K3W z#nXcXDV6SzDud<@%DOifDf(vf_}dErEIjBeSgN8sApr7((GNc9_B;F;rB0q%mkKwF z@C9d#v+)Ib3v56ueL(fFX9z44sM8>wejVip??K^7PJBoX;!-z8yJ9J6{3zQQ$-QYm zvb1MV&WA-{T*rQ=q26RA^GjU5MIM@`MzRwjMJanK;c7#D~)W7@IkYEo}y`^XWn*{pXVA+579*H32z`^ zEX}_t*u@@EI^jihhCaEj*HYmk{|jEn@m6Fg0y zu|o4*rzoT>JDYd%zr8>gXGhTG1HqnD{j6FGm2`DZVNX^TsBD8KzVL7p|I>! znVeuDP?}rr0BGzD7&&~k(wiHlr(6`IYGh563nH9xb70dgb)|FbP9cFDt#AW9HPj+G4h#a+z)`jUg ziV{ua2>+UnP)^@sM7na9IN zEtxaRa@g)K8cz@3f?lv-&t4CqkqQ)BqPPnbRUYC+va#mFBZwPk%T+j|%kg8+jGHbh z_7HzxrHYD-Nwc!A0eiJ-O{Bx7(k)xsp#*!vYH6qPFNCsHyxgDrPLSD<=N6KpG$Ju6C6M3J`{)4-(++U%6_EYI=ofYdt z_r^9H#^u%9Lo%Lt1^r@(I|>+EymuQUdm627X=O~!K*shXwjS5o`w}2WTisb4Is`>( zEp8`5unV+YYUQPVlFOzOuOyi`{T!nvEdyakkr|HOK>OrEi8#HOoanIZ830y2O@Tw% zM%)~P4xve)@p)*tJKL8?oGcV=5>C?h$X|?wU1ocD47~Q0t;OV9OeiHN)zGQvx|dif zZqeIdPd$PqkhiG3&vciLfj|9~JF+zJK2>v(0MII`)W_}TQ@R}Oa&>6ECpdogNHVx$9aXgBkv;JZmiSu#uj=u7kbzN_Y zbC_(n8^(qLG&7nEqj(dBeSQ}gH>ZSA;slfPvI*nS$|ufNQmdkSrE^`jwibK7`$fr{ zpp}fZNst%PZpI0FvGS2MA(uTJGWF3EAj*kn;NgJH1d}xyT|5ZA>Wki%YT539q{Mg@ z-{n6n6fIvU6fJ@1DB&}upX*pwAK2D!91Z=Kz)!%>=Sdq>hmIJ1iX}f~hP0sJBWxb7 z3?1PEg!LKDW!r?PPMV}2qGmT*fAKl1&)y+Ew#a)}u?>xIU7D3c&**VPWZ+gg^kPe% zQ4Xt~BUs!n6CM6pwL3sro4-aSg;-O!O+*4T%vBf>eu11hP`O)Da@C~W{<0ma>V~`( z-+R6IxCWwKeAQLkC^~DaYY~?Yr`FdFTdm8~yuT9W#d)RibMx|x?5-Wo9bi*n!yBV( z`hGH=xLreHp1l1X6WK+S)&`^2pUHxcD4GjiOv=Zr9;{u+&VD~22smRDMh{X~(I|Sm z!g(+$o#sXasT2anP&!GoN~*PNHStEmO`gxjz4CKm-s!S^l$VNUYn_qLc-bDX%@RTa z6+@8*_nhyAyA78%lh_Hw8Dw)qT_D>7n%$#609?)X6p!9YDc`;DaV)^(gKLxtn={fi zfE#=BQ@7L8NmsTHo-r+|aqo+JDUtW%+wK|z<>;`_s99(3gOyY=?s^@2-jZm0mOTmc-VWJ(rM!d@?$EbNf92u za4JlZ4Q2d&!n;ss?>LqHPQJWmm#|CZWc(FqQ(JaB|VUzsKvxmPOpaBs73qD zoroH_Q$!5G@-DldkAv;8-p`53F?X>d-eK58P60W*jh?dnw8 zacM{JPFDHG*|UV~HD^OOR~y~Ius%{w@6^ZJI5W`m&#T+UI&Ba9xm9 zHgc9mGWe5Mr)_Tp&!GzmmNuM5v@UD2CU~Qt(gTYFQf(2`k(e6W2CGz3){^iZ{OXc$N|3 zy`(eV?p$l|MUu`oQSX+1rF0Z@^fzTIFTE+H)wH zm<6%n<2KKdkx=fRH_g8w_}7I?0+x8J)zV(B5`+k2dlpOb>Z)9#kaccd(*K2A%_XRb$oelK)<=#Pi8$MLvU3(r6B1Su@Y zYrS?q(t6^tNYT8~#}Y^7m_?M;ajasTT%Y*l;wq=7b&mOrAVY4&MLSd5b({TZZO2+#fOy!+V85UA3B%(RpURxJ(A;Hu# z9qugCVK39pBIv7RkB~~6&am!SExispgMG(ru69b z3AAeFLDY~nm$=LE(asUs6i-9xqjCP>~u$0+VX-MP9CBAg_IMYsh&D5S1^eIrndiFw)+Ig?r znMtCQDrVK0$Fzk2Bgfrf8^6d9*|r)%^0I$5abB;or``S&torB+frPfR5@*sq*i(_( zjOBo}9%&Ih3)N8JJ(X&$%iB-8H6(dpU%8gOjENf)cvJLVW@+mT_a~wB2GXu-``0>^&uU<Jc;w3Jt((mG5;?}d44(B zX#3UH>VbE{(z~3v@HG!uZEC59|B_bB7?vOW{13p!vCJEjf?CjIgo`~kl+ge3D20w+ z<8z+Q$`+b-s_ZyTbnwqU02lNoBlUSMn`pMIq`d+$&b#tG2S}HuF=#@0Hbql*Ifd%? zY;iuKPAtC_-Ciz3`7o=Ry$y^W2DIB@s<-A3jY}`U!|VO!;W9t-y7;j>(P1bbgI-QL zXOK=`W$lKqd#f@1Th>JzC!ipH}nVMR0@}fyoQ^suETCbqquBx5& z=&N)cu5wViMOm1 z(q{1S6#2~SRAvgDaOv6B*QP5Pvnk0*u1P4fw^Ft{ZQlq@*>Gp`2ny?hIGqjYjiJoC ztdUL%FHHED6xsGV0`3l~P%qnx?eD@S`o4-axiA%evn@cl=!yK|r|{FcN(TwxrDUPW z)kmC-%xtzJSM6*T+L$65q5(i&hM$Tu@vTPM&s^J zTQt!0^;Os|TM3gMMzi0U3`C8i@P4tho2-g-(e z!F?9A+5}{gz>K1vUCqAF?=Ds6k@^YK2darDl}d+C*4)01*TxiYrJT20sCcGScWYS z30jrod`)i+BAunC6PFJUQdlKOZWo0%(Ib{RFr(NSNK*|)X)fGtpu`ZOw*e@t6RFSo z=n43fjJ?u&HC(Be^$0>xKXVXIGtpA7 zL0@Tcsd{ZVeI_x&jB)V{n{Gt%xuIHGKjD4$6wi;Pf;q!8RAf>5bSpWndB%uy4ta32 z>~R9>!TnbyCSz}H`g7yZx5x+wFN}s;dUJ^gTlZF%x`Rn`;9Eq?vKvO?TdWynY%HMa zTP#Z1$toH3FM?{>Aj#CSZTKCs{DnLFem>)n6!JH}wDLKgzk5Ue%;>?Vrp6=CvWkk* z-Elewqio|MdUcBS@z7?Jqokq6RN|NIituf(^ofQe39y>~R6eVl?Ar%oD zHd>u1)?c>3@bz5ty{(XzaP;XXqoGif?Cidw}Qc`Y~dPv5KKB} z&6HvELnz>Emh`&mD$Q4h_#+>v@ryj2mggzYhiK|Qmn8~bIbPPuYaV_{Yjy|E&lAt5 zi)TSCXtJ-(^Zw4W_)izR+hq}(x@bc^yu45G~ok8$NgPz##mhN8Ue51Wbi*>=B?$~ev% zL>*HzqPW+qh(i#a0z6f^>=nFP6{Uc4VSrGBQhZ|f)1WZvz)fJXSLaP(E-ja<^=MxCNQj#qtb1U@OK z1x<2WPhKA{^!nh=QKT$a(;(28ZU*&B-iGYxl^Rq^fBit|1?#J z>`~)f!khC5XMt~0yGCOhi|aP3CpH#i?I9eN;Gl=;<-QrF7oS^}l$IRgV{a};NnS#h z8is~js7;XT`ONc_wd6$U!OpjOF_fDbK8nTG?Rau|K<7SR53c^4oNdW?WI9+>|jF{25k5ROgC8HQMEkDN1ll?Vkv@DEB! zf*{hZntR$HaEaN~YP1k!J&+OI;jVZ-zjMY{z<}^a(b(vz7CI26Yw*FG|e`q}!-)RrlT}-)?okfRx*P@_pVX z1?=dPHPc(a1N`|uOzJ?D)o>U*v%QrJWj|BD)INq(Cl|KkFF1ZH6nxC+GWl9n8FvV} zl0ND3g`jJdLJ#_tgn#cV4A|$Z*dtIe3$)HvUTac}39Dh*aF1dX^7Xl49I;1!3py95 z%5v(A=@<_bV@QjzMoVLepcXXAElG?aJ2IWVQZZpbbtuvPB9$|1vCZ53lum~@^~QFc zsZsDkt^tlg0XvBctGP4vsWi_rIP!qNapP?BYMqVH^d>y%n*})_O3&fDUh7_4?~?f6 zT=^U9jNKONmSVvcRKRVWFexvFe^TDTvSDf1vaFK6S=m9aD+GNFBVT8}GvqB>1lA1e z%!SBP(j2`@cqwB*J!-rKW}7=IxyD=NdY()l}Z<*XoH*!ByYcCkt3INmpV}VhFZ?fGygFj zuKUgF*#-QZ_X{00kUrq;Dl66dhiHNCCeMoo&;L2q!eQ3&KT-VS|KX=Svoy{D|8gND z!{d7o<>AE^a!2^Q@xzMngY%iGBYgh&aYgv`GlVY~Ke-5}q4>fRO&0;crqMF5ma9l=h>~>2HQ%<7*J} zougpWIc3;b0vU#lrTSEwJBg^q@DmuLeEh&}UVD;=iCUSdk1>WQmc|lA)7Rn^`m~^1 z)H+x?^^568Vb$7V0HH7GMTGn=gV}bE^n1W*TnLoCf0?w|UH{$X_90S~(WX<3%e5rC z6AZL87l{f51iu5=!8|}(?}ZL3!u1(o9((L7n~P%`my)s(#pcrpNhui=&uE&<*^i*P zv?IZRWN4r|D!HlFj{zxpAE+hhmp`c6io5!|xGfd)MGRL^PfHQqUz=OEqg+*!TB_Wo zTFu@GhodW?p_^6xLe|Cjy8Pu|D+W}B(0><*?I`^i2kCNAN84)xix*PSenE8=nJx8I zs)u{sUl7^OL_D;YG%MUpq!)$v()6h-5{=oB6^-}6{UoEe>MH1enLQ;7OXgY(_WM*v z9l39ON+&1Kpl(u8r$1HI=X1NpGaCODhvRO#m9VN;4TRzny(`RBTwEhQbS8;0>@Ega#vJ}1VrtY@X zs!(1wuWeWA+1cl{g{*0%w)%jVfzvWl-L5t6shJ|Snq92ckiCcB?7jS;$9W&0T6PJ) zmeQ0fhHT!mw1!GM@8xN&Xk4j$ag|1yyQr+rd9B;n{$GeRmni^V)CTk}>wdUDsJynb z#tbX0Bzr#*OxZqY+gCaG1Ax1?T+VR6gYnW++WDDzzAJV<=|iG#>hYX3JvIAao~J1< zo3!&(Ee$SoI+~ZC0-qm-PUAyFt0&`kGPq?Q#+_KvWgn4qQu*}$QM7l2{_DLxw5RXY zw&Q2xjqQ>nmibO+gVv^dF1qdP7D=*>R~zVvI!oLHH{IzC5*fBse!juaqkHT$kmF@cF(79A}Cd5v5A&fD|dXiZ$Alr=_?!LPT z;+BJUi1rSmVJtjDv;&A%%g!L2JHI@9sL==AB?INdk)D(xBim&v+OCc}wlz~H_2v`5IZW@>JJ}op zte|>~k158%oFle5X+dfDX*unh&Bd3uX|vq`i8$-$7pj)RMI8lFZC9P8FeP6}Hdle&H{o8UI+#Z~*jlke^OPrKX8=8v_<=$d=}U04x@cEsdT5 zcmxGwi;R{A%m6HwkS&do0r-sqQ^R5a7K^=>M#2Cr7H};MegRl4J6js>0`Qv!O$~7Y z_^kq{Q7r(!QvfxP1z@qxYiaBXz+!FJ(r^`k-z%bPgbKi71=iA_6oAFLt)+1&05=uU zHS`2vu>@>svGcWeaqV++(Wu z4E+)U%O(zrdTp)V4REsQ%)-Ce{Pn_5D^v-eFjk!cPdXep>iX zGe2=ds>hrEZH0fW`B8I)@HOVYt?=(=eheZ)_+s;)Sor6d|B~FlriwpG=SZ6825W{= z8xLA0U`HAC82~1=V8=yYa10YwHzB2aLg6_^%XFC{=Qj7N!Iiw>a{G_)O&+EY>EH&_ z+bnc|cl-_n=Su3MV%oyS5dCQmDo6uk{t?UDaT_D(Km$H8)6u- zd;ul4kFf_t*wiMtM|6Kg0guCDN5oGQzjxl0_-&ZQ z-;M)L7QcW`kH6gv@eOA2HE6Ws3!cZ9&UhQj<)hY4??r*Y>Pv;2{s#BPqFnd%`^8NG z8*!HZ`p||I*W2)>L-Q)K>mhlfEo1TtRzV}2n`dYWSBKhqn{ev|w)1bO>2IaJ^_w~R z)li@bgAZM)&BvTv=Xyn&sz%hp*(I6jgLXYR6OI$DS>I{ zCXQ5#@ivs>e_Z%d?2SKbOZ;Ox@w;rDbhUVF9ZNvC+sg{l6x}09`gN@eIdCX@61NKs z9=BMZJFAv{O(=d3p7uGZwbCb`87`V|(~|5NEC;6CJ;B8_iABZI*HWK7Yx7VKEyg64 za0o?Zb4=7aE@y6hFS6uz?39n&p*#m@oc~nap7C&RS5x73e&^xv%(bch?=UPca{pX11@^UnxG_WWojd0Y(0NAAh@#SVcM->lA#+x2FssZ9` zF%avI3wK*sx*z(VH@-wD+kvpw8OqU)xR6E-`V`#RQ~Bv0eLDE`4W1dP_awEXh9&A! z++!MRYGxs-`dsu2XquidY{Ha_1kGhbe=M%H=1XLuXDSX zmqFLAotQ)rQQzVngmsL;=o{;CN4h? zcbtaV&~6;(TH(BZYdB@IMf{?0&R>u}i#&yxw?UoAE0w+^ya&PKvfRcsmQ<0J!mm^K z9t*b`{$+)Kai(y;hw>{5U$!kOe%eX6=k68?Bxh)|CmGV5WkUK_73XT=a2Rl=@UJO+ z&+RPSODFGF9{+lUU$yn{uPc1+_FIkr4TZmT>*3#2c(iDS_=$}N-%|KG!g)=Emdsex zF*jJoyQ_`BxYvc(*|!z%gBGu|h*qk7bmDzScz=E}Jg?jD3hx<<#pkrT^>VsF;TKqV zwl8YIGKUv9pV{u=d_n9aA=bDK_OBK?%pc(KtqCxrXqfg)VTg`)H&hJt;I@$I(4 z>9GPz9AMAZukDJ{;|viUw({(f)+6e`QF^?SFgyL126v#B+hwFD1UULni*G^>3x;&P z2T0a<4(a_sb!RB`C|yBHt9DQ+O&HgoQOahLm147yjB1VJMrd57ZAT1)p~#{qnyL}B z0BSqqe(WaQRpgW~SCyo@;aUEB%cJD6rvbiIXhJUdjiD*Cmmm#P>P1%wP9GP9t zE;$$dJLT|8f^`K}i~kMb88by2PM;+L(LDbSS%s=R{uzo>jU<@sJV*|6V~=pF(+=vf z&lF+tYj;B_TL^|{(P$OHE@?89qEz<+-^%pm?L6Lo`}MZW4-MXQ%{DTY3gdHiZH z+p`-Q!J0`Sb~#vg)h-8Hesff9D&OK!<%q0Y@SMAqdC7)K??=`a6a%44Z3u0aiV)47 zXmiX)4V>Fv5+e(BAw@MK8g&_K9M~{JGo`0B$}6G!W6Q^uXCo5A(q2ez^j6FjKi-Nv z0{p(gke-c7o~T{d7kd9{NYLt@t&h^(lk?r;I}DA;E49+`r1cZ!&#TQFM7zRJ5UQNJ zqan-1=u*(D9YyN+=!)1(oT)CVc1_#L?}xds%kEhHsg-BwTbqyGA7zWZPa-Od_}5oz z5O`NRqzf6_c-3Os-pED|Q%WrQw=K8AcoFKAF=`J*7@Cr6*$;qq@k7xZG zDHrY=-&)+)MiUD1Ws*5N?h3cI+||AZ&Zh{kG;7I=o>*;dtB2yE(b*tvSN|EbX3&la z&e~ggh{`tGkKa(_VUs%zGxL7&VSh1caD~c{#QFmop>}I=*J77unEO#Z@s2oK(RBep9)5<|22rn^M ziKgqI%1Bkn34Z-UQca&jfE~z;@H|&s&s4tMHjm#`ly6;|Br4NxMN{dq$Sh~8#7r1i zwkSla&l$?Cr?i@^-#xwDrY50M!O%qGPp#}jk`+N1s`B;JY|~Hv5?Zn8Hu8(J*0U1g zs#m)iGve}a>5sB2X$P1X;I(^G1C%?jIOtKc9?xUlK1Ms;U;W?ceso5f>pbo0Yl;@z&8;(7zSdBZm6xv_zEZ_UK?Sh~B z1k%hq_0miE{#xap9;HxguA%pFSWDe^X_(wu;b2y{c|BNho*HkmQ3t&$Oh-RBnF*}H7Z+UvnW5t_x z0oYjF8^nI3CbS`rn=*NKD{N#ctZuMyw&qpfGA4HUqg6^2O@^#g%4VgKz6j(npY+&T z2oze$Y8vX+E@nQby%LJE{b-NP(@2DAO`q)9#N;9)ew(imxDqa&v4+$V9{(C*ELznOPx}a|izAMv#W}#^C?t zO?SiU+_C;b5*oUq^epgXdnQ}IXn_&1alD}6MIfUxgbC4S?IPA$N9uET9WqO!ZLOj< zYlyLW;8Qx{2sS_Qs$SO$z+aTUS=loSHcvcz33qu^0Q}4xj!CnMYs&)4d0xHRc~<+|4WbXymKv9Fh=!Zen{Q_GA}KdHoKa3HO^!XV zWZs-yPN?N)-u(0e4XaEEQC;jTVyuR>rqGLc`e%-@ge2)ijY@Ma#-%J%yXAsnCDG;g~jmmd*OdH;J+>4 zUo|uSPT)T*{Er3vb5)4tCMPm1nU7D67W%WN^9RMdI>h71hDG?q)Ck`H%XYT$kHWtu z;B%-$>2Rz=b@uiU`;${+=i`UR|C8c>D#U+>$G_0yUlihhdTa4jE`L`1&xH8z3^6`C zHAW}De-ZxY0zQV{;ujlY@ry`hx&8dq*v_x|@G{cVU-bV`|BDw-t^Y^F#}@)0?+Gbi zTcmtRXZ@=_9~J%=13qJw_{J{T82-}KXjAI*F~z$s#JeO!`0~^UdHF0RoxckID*^w1 z1O8XH#MjxRydRavB(_EALBDrP>u+Qf4_9vevi zPyI;x+rPnY)Otfl_rDr0e8>~jf`)W{jP1yU+`g)UC7$y9<*2o>BjP8Dh=N+s&`{&0 zV##BvFKV3nyQMkN5%roPs-P|XEVP*Q;gF=#QyY2_@gG-wFOUJe?u@e&NNGuZOx%T1 z^iUOI5vr0Nv=x5^ic0$LFee;#n76r>Po4|It9crfw>66)5*$ z$SMJ*C7rv=o#D*6HXk9oC@%Y*W+1QciR44ymxb@k!}p}{HPK_G>v37CZGXISJTesJ z*O|$kUu7nDevO&j+vhUp?ycWTZyINlOw15ih>qt%==?)vYfBn*DiR=BucJM913$6J zG2K;EaIYX>OH0Mh2nSgN2{Ao2BD|6aNhZPFmeh%h!Ly(Kn=P#o4br)ixy#yHN-<&~ z)4R;=5~I>#r5#Vt-PO_=XSU6U``Ia~4Lporw zDXvCJr^FkC;yo+ALhkfBp`)zc-SKnO(mtJjS3T<<1*IFCr3o3(nr%PIM1LMM{gO*( zuzlC0V3_6?ILde03)4ko*`?TZ@!I1WNwd+Q zvl5;d8O~U#*K=5u&1R2zjY&^KNp>@y5X9lYqYO0)@Q@*;zw(V|!`kL;R5+?5)(Nv9 zN)5bKMNXc(sijisU+|Y7237wX8ud;gtN_nWrfFa#>%0hgk;hD6OWH30-EWR zg!WRNj|^jUx7}3&Hf7pDEvTIQN*xnZ^H34V^;0Jxu@?I~ExYHk@lC=f&w(#9PjK&B zlo|Fdl{dAcx5hi~2{v!VW z4#Xz0Ut%h}$*|xVJ$m z+ddcYcL2|Cv`K#xcv5-_5PzhnxW?skt)pU9b|aE)`cP!}zlFVSX&5A>C8qv~C)-B+GDj zSFLq~dmMhhYIY4N_!18tY#DzaQpsyw{y{#Z3byLq=DYD?xIee?^g z^po{-!Z=0yQ&8YGPV+v2e&H%6te{`GwLO%^&5K1-cT9gw>)3cgeg{Gyo1{M|?Uj+i zvwJ!Cr#4I<7G9h^=zzli=rsRh?q^RYjGylz8Z+2?^-1R_6rKgN%d@QM43BV9Re5tb z@`$CG`=!n93^&^c@K1^+L^Z!Q!XwLm4CFlSsTde{#@%HaE!{oY8NMR;^E*j$I(A6R z%R#)y;rLaN&dOP`^6#1BSM1hl^n_)zSEl3i521c|ADQQ!o_bS`#I~lbkMD@W zMIiCKBOArJ`%ol*WzgkCzy3%xmxDJ8nvqeot$nHLtzGDBsaLH%TgEwMPffHnp5#2| zkD7JxY_~S$Ww@7TN$;9j8S5sG{DO^~Mz)V5<#D6{S30?0>aI?|q(J!(Ve5sqY^$C8 zR;Rqp2qBMe2N1y*O#j+T(Yir@QF2~-r5~VnI??UL|<-$%(7pD@UH|w${&fG30YvEb``0xnuH+I4&1N^g*RpuP*d(H$D zWoHRXsT)NIAGgO`hCghvFgvWa!)Y{ zG``CakE%a?GsxNZ@I;NTv94!5l#b=CI>~M&Ajy8H-yow`>`u2bH1$RjR?e%1ttNnd zP$O=mZA-)AH1A+6=;>$QYPP2`cdnHRAM>(1EXIcTV9*2 zmH_~l)P4h$p7Pq7v;Cm>GK1-un`v&sXM58LPZ%9c!ts*q7GOyH-`7X=rnaYYc|C6Z zMZ?ab_V{Q{Z=o>GWQn*iT3~QnFO`Qk4+)n294b-ybh*#dPkKN*cOBqWCS-L0(mlWn zg|nUC(JekU`kQ=gjJ3%`+gZBHAB0=o`ngv}(Dt3BN%*~lujvT4!Z%HQlzp9Y8h=Q& z{Z_J+n@wfk0=(=-@+$isP1>C{9AG98%c)H_-eiOlLug!>t$ z((!l0y41D?4`+)s-LIV}_HZI)@*xe!+T~qCBjvUJU{dyLIAU32BDA;cq}=*|#+J8H zntJmkI~NCa;5=7KYbb}h(xM$3CQo}#ZNQ7c@asuqqffe`F{Qx{hdx%bJL|et2G%L+ z(V{NT{Ps|Z7CQGPSPohvG!4*@R}^ND+7XP?KS_STKEwJ<>|KV3*or=&wQNr)=L0(m zXTB$;Wk+o0U@=xpR!6G44otsCp3t8X$_){YWc1GsjmkN>Q=D+@ORe(o$XX$MaAr%x zMQmr6GZGoAy}jsKw#Ck3^jN!3#8!yQP^ z71DV^64ZhwHNto~ENGaRjXnMYN{V|{xu^0VCU|C_OAV`3dMFy?Rj=nkXN#@6U`agX zVdIYw4Pp0w1{AwnQvUY4#^$s6<1nQ%A-}!oyZ$PAlICtpc07cf597gk0nS|gqP1=Q z#<5Y*bQ0b;F8ojO#qZ$7?^PkndzIM^Fe zr#@B=%foO9Gq=)gjZwM zy%Jo`-dU89<~A+H_2+LfuaY^56P}5M?jqFY^?Y1KM)l%ic**X=3)W1$9-5tLfVg~=SPYe3J&-?S8>D|H7&M z6t!4rlYONR!pnf#Bu_!`Vi6%>40&Jim}eM6+M-#w8mfIfp`87I%vyuyxU)6ra&{x% z=H*lx`>I#!(^qMJR6RBQGovlDS2t{}Qk5_TsAxS(_B-Nb@1cAfJHSozGNOb&#+Y)N zSU)0~xIzSNBr*xg*Lb^Qd!xE^2}U+1hVN4Bgm}n?FdwvA;OI4W&VjQ6qG|H0pURBV z=PMET+FE?wD@Xhn2n`z;i|KrbK0(ia8zx)5I@mu`GYPxb)y(RG5U9i(Ri zYb*c#iX&1IHo%kArnOHEvkOymm{m%C{ul4O+HNRl<7npJw7`;$vzU^)@)Kse`EsYU6doir~2&E$pw)dtb*7$9qD}2&*8L!Ls>gHL# zZnqw0;-mL7Yu|2n@0|^+zcb-vbUUjqHDO;BSO?-#DJo!<#A+(BN#OE3J#t9P?ZD@Y zzlp10VoN)4L7&VHe8IH1op#_`i~CwnEZBhyYq}kHx7|Mp+tOPoPo4#D%{J7SGh0HK z4-4t(a@y+E4aB`QwFipyd=R4SZTwO-mVfkyDwEt6{5%EGn}le(C?&Me@~1H;PUoA= za$@&Unu#^Cn@e9#@1ek~O>XH0kg-R{dAwVxIP@KYicRjF#7T0Ntl0^j0(e`}3pZ}r zbY`Lfx(ziEUXZU_+e(IZyT@B#n8w~qHFt+5R!uL0uxW{>+=miS-v=u8zUg~GQhx|~ z>bVEIj#%%1tbh;wMShqdQ!BKQ-Bb&qN9mY>pDBn^WlFS|L$yDD3~{$pxuq8pP!D`1 zZN8@LQihJ9wNa-8@eHDNiV4re&+9Q$`L34c&Ud~q?Ih!axRsyHnIY@>e0oD{E3sAD zRg!G?PO%?ncfdgbdzWAee779x%iU(HrgA|@{Ry~nb{oHg*(H>yFy8}a*>|74ES@Be zS$!38u#b>{?ESyb-u9j$oe*a@y_keZaL62G-~aZq@3TFI?J4^>lj5MLbHZbP?O7gcS?qo-zN6L4#e8=eukd&@=@?$}vgT7FEs{YdAy$auJuWXHnr zqXyG%N^z#JY+G_(=al*XQifqoI@{z-<)6;+0cF)j?+z(pO&ASqx|!B)Ok38`ZcIz2 zXVPXSweq@9?zuhsC6=HKmBAi;sPtKQS#0h3{e+ryQ4dqFnQVoor#6wk6pUh%z*?Y| zQ{8hB8jM{vnW{fSVM8>k2U+>^`J&3>{UDF+MS6;0(WfoUI-E*~0fVDMRWXt&FJ z1`B!nc!#_o#kbLw%6E#P`k`=cb63nE>hXYJJlW89&}9>UJmJ4ps+hM^i*kZ5Id8Gc*#DttEOkKL)ALuG|iDN70xN z*dJCir%Oe?Zc^f@#Gx^_f)T2PBkGy@;=!3P^}CO#6PA6Keo9lMAD47(swwDeY-{yjY>f@|H#r5NDlt-gfg|Sp+upq6eiTu|uvcQuyN7hD-4^WZm zCsoSOy##rk-KQ-SBuvHEP*dy-eTL6S>6cr<3yYw>rxdF8xcLc1EH^)?h$lr8@`lY> zIWybVQw5?k5kR^V!_D`rmQV-AWkXzY-y2VP`prc7m|nMcYL{AF=}IDc-lw4CS8(vu z)fb58$5oQ_THG8^`Jz5?`X&Ed$0xMoYDq>#`is-Ac<3DnCQT7^2HlW9O20v6gVAeyu%T z$#*Bq*4G}0VmbVXjrqDT|Pu=y0KcUTQIiD!XLvmVb>FSCnmK_h1ydTkyvOnNP?)!_~>g0UWe$`0) z9Sy6>P#|0ld@gzQ{B+n(PkdUHg`~v$93R%OBLAqDq?~bP8U6@CE~$o^v3MRBr>dmv zQc#TV6QcANTHu(dV$svMJ*LKH^SQIy)s5&XWtaSE*E&9uHP*70vweEoy3&4i-|+YQ}7qsulND7})FqgE?`Gtdzyxmiiu2wR= zbWn_Gtat5IV6AH-1hN%Wyw^pS*^2CO#E@S37bScd*(H3io@#Em#d5~HiXe2Jb_OmBn}8`oMx z;0`2rpH3+7n*`T#f7ldBuG?XOVN-vQ1+PcEv~5l}kerNJx?2Cxz-r;pl1 zRLy=zHaN`spg#6A2aiSnoa`qf{rNc7Yj%?)D;XS}S!+-P9)rM`40r;tN5H=ds2#jc z;NJvX+XnUt^X~%c+-AUBDB$A)GS*B1{zE|97xmN)^Pd1YHU(OfTmW7{neGZvy#n23d^ow zR4D3se(4<2WGjOHn=#9CRRF_e`aO!C$6dKg2vCx#DP~s^uRF=^#@#bFNBqz-)5o(>OsSyW60dm4N(auhwo z@BTAC;(`r^+-LDIapH>g*vB=|7>PFg25N(w;}N;vM}_3>cjWFB%0^8> z*-Dkg#Am6>E%g(EKAC>v>C@tN>L<1q7nwvsK|dkqRQ&`t#sZ^8Q^no6l!LtDJoTIIoPZ))bS> zv%`JK{MA~oCK5xn{uzd#CO&#j>|?Fu)xkNlWO$;HbM~x^$wJbY*I%FMRCb4c>^H6> z!K#X+Dc8KoK>0f+$@1JNdz=X+gwTevotXq1B2`)MVv=Tth_ zHfUC%oxV+Q_PNYINGB`i);gOl*znl3@9Jx^jk|;Ivs70mcDs@G;K=xPPc7s$jm^Bt zF++G+6KB%C-;s?;mBmyd6(Lo#{m4a6ZHDkf;kE1+5osH*m;w zVX#;&H$Fv)Hor!|An!B`_6+v&%<|wsWpE%F9H>#p-51NydzlOHUFlya#nIP!NI5OdB4jSUXhNLQ zdatIH+B6B(N;-@1F^M<$l9VacClh?tG@cf>nte@iHQo|lOUnwkS>I{bvg--&uQOTJ z^%BGdC-1eKHyvuLc2xQ`JzJSHKBEHpf=a5UhjaqqTJcu#EDSr&7ljk2cQJ?BqvLUU zH%@!@(uRYS$E-4GP61yB7Rz z+hk@u_#z&uwPhmQ+f{4m0W5AivTCH8>p?28z693t9~E~_lw+0n=5ZA+_OXxA08 zp6x4rfb{oJ-FQ)kYmQX{h&pN?*dJwja?GS>-xnB(?P&;md$+sVlV4Dw!$4Y8jIQA) z&K8q*x1o>Izd&?|u{T-|#Y^+h|b=E@NRv6K!TW2v%KsR~r9g zTbbLsR%ceqc5VZUJleAOt0(E>WW(eL)@Xik#(22MkIfA4X$Ap9*>%*)qJv#KJ)C|S zpU-=;$I)Q9H#DOSTp6(N3jH8|>yryF$(iy=XjeIeyDQX<)VIIOx9Hn@x7^#qgg1G#TFxSQh4byQX+D;l#H0w=#CzNJ^GT4_r*s+sO+ zU(pY$^z3>iV@7>R_I2Fd*hGDU@79k91U-FUY4Hk|J(NZ*q#<`#a334_`-|C|xX>w+ zgrhC)VPxG}>GR}sKdayUbwFzTRW#4;@eTa;B1%N8HvNzyt z-9Vw+QjmN4yNTKO9?(faEhw#rvcZn*MnckK8KbhB?1wnYdahda$8*()`m=hw(qV|1-XiH5Hk{(=>O0E=<)MMf=trY`<)i~R*`-xzKniud+wF8N3r)8X&V))myN$&2 zb(x=MK2ZHi+S2EfU{bvVP3fgnH-&yA6~s)I_7UCGg-mBZQ$a~4z*WaR-3bEg-JZ z(sRU|Y^r%&GKlVFS#}pl*3b0jmG&kMF6d`>6ILJH6Cm=+FY!o*{}o>&%^O%o+$3`X z?jax@BKfcrt}^p{5&PE!F2By_a4x((lJ4dYkAyLC}&3JCgYO`;ax;AlTwfyb%+3sA*paN^$ zD=@Y|v$v$&)q)Fy2$Wlgc)BP{vFyAlvMz@d^9X^nT*8H*u@*u$y|O zc8XVwzjY+nkwDMFc5gi(%sBg&P&s-pvPvaYB6Fv6LM5Na2gKhxl!5 z2meY}dY8p~pGz6U8=lH+7dE@%D-;KPtJrY2_Z7dN{CS=DzREJ{hG|I<^(k;cA|5X> zd)q@*)`+O^Kwj7*t|F8>84L_5ft%s^b8b3oN`JR@RL6KItEnr9bjB z`6q+woW@Z4XWZ#u9I!iycKVk_OeZ1i;xLAm8;^k8e3YLEIZ)rmV}ksZAM$Z1dW^p* za6*9W?}FA5!e#rj6U-f^yiGg~c*)oT{91w;=05;6{wa99so*enBePiWzW}K&PMShL zKJR!n_a{8?EDjH}({|?K?B4{Iv&~Ny|34n6JsXO%v{pQJW&^v?Qo@U1N{o?V7H+$7 zK8PfIOz;EDn#QvNHY;F8!u?rRnd~|$Qt-L zLi`x0J~|(NlGO}7ikD3#`{Y1E`o~hp;@BC`ZBavY&sFs$kbb042O!2o?R$WS* zbk@oCRv8aDOzR$S(v)%zb-fV)yY5KDW7nXk(Z<=j&rfKbh| z6(-qPa_$R6W66YqV;y^wBUwC22n$B0p>&S0z3=GWfzJYbq2f469hWYeR@M)0_vq6= zVL+XWhnry4dTZGL9;;f@g1OO@Nd$UxP?HA{2Ekc=L$OeLjanVF>USlp_JSlk(jfHO z78p9_Av{`aDRpKf70pt>!y}rl&=5E@921nk4 zPv=2mWXHVQlky?)d8a|AY`;DjlvX;-k-=Heny+ZQ^SFTTqa9raQfI|Enj z+POy{7c{fkKWx?+doiJaB!LY!M)>WnmK!I4=kL;lhrdYK7}zaeLe}<`GPz0axe$@(&4_) zLhTNNfPZ9;e`k(w4)7)GijO1JW}W=7N%EY!j4w^n7X?}xPul4_lzO-;r)Li6fFoYv z@i>dgo~rrBzZUayNP0De6+%ppb9Wx!9K*NSK|gdNf#tlu zvBmW`&0m4aOnr}HFfY&@3^E}=Hj6T*9S_S`%jVcTP08PDpsPRM1+27wO^ows9J8{! ziMC22Op26NH`p9@SL5>RI8>ym<`1UrEcLq1>8^aEsBGRwWK_2~{7UCHZv7V0*?s)@ zdV|YCPHTLE64PO@(=GcQ<=e>1<6h-XeZd??cj7lW%pAZL(g!Nc%tukrgS;?^E~2{{ zH*Y}+Q5pLqUAwO`_5h#3o+urMvTIGvIVT={4j~vU0S_F&``H!;As7p+~%u|*TF|)JB=}dT2MM0QP_8Xt30Tvou2JMKpDdR=(5&* z9kE}p*ozcfPzy@?K}zTHqXmwglp8+(D#}AomkfD^E|h%b6{Pi{RV=XU%G)=8-tGO1buxi{iA+r8rR3 z&XMmAStGn#tGE8DDa3dR*`^G)9k9KRcg;Hfu~|YXT^rf@CEBzv>D!Y|w)&5<9ZBEx zEdFqq7Ref%^v2g?RO->Rsm4P=yY+qA#b7tb?qaLs?oH3liB&U%c;CaSjturx{W+=( z0)xGc-xFPGgrxZc2vqHrHi{0{$H+`F zAx@DxRcTg#Eqfch2gL|4RS);0`{+ua!LYIZU?LwrO4-mZ zI^Lq|cfgrNRy0m@WX1DPuaLkFlg^ z^07ILVaLZWbC4eM%I|WRIe_Wz`=|2NUzBbX2?kx?i=le3X``)gyADg9fpk|4?hO$r4hAy?$d$l%x z6j`~{bSw~9d2@R&J~mzNi%4tU`O>X1fiBwR1Ih5B#UDr}m9Fu$XPBE7?UJ6Y0wAvs z=6N*-sSfPMFi5v}F|^2|j0@@&QzukR0g+@ok%6&aiD~adKQ-qP5(CFyHLp5*z z>^D<08UPo#a!>~7ewaKZL*cbvQpidbljmPTc~sVJ(1608 ztkek=43R}7J%=A1Z#8*I_f)=;&||?Lt~a_=ERiWsdq#H#Ud!H$BDL4I2!>oQQ?-Y- zcsR7nUvXPSq@^`ewl4qS-P-f7Z9o+|OJkIeq-7sTtNu={?^Vn$tvkC9D1D3aV>VZsN!-s8Ta7x-_E1|$?C?<1Q60-v z9cGwN?to&BRbQ_*JyLcip{G8Z%N>$^kTj;rK3%qF0BULcG}?NlZSP_lk+SJ$tS#qs zkhg-I`5t(uYrl_=jRh0G&&$9Z(4<@*&SBkYp$}Xc+E;t#cI^8RW&PNuQHR)Jdqol(X4Q|axiHGdU1RM4| z1yGs>K_?-^ z8HrePH25woj!p1@L|o{5Gonh z?$qh+-afULdu+6+$(qt;>NvfgqPs$V^z?dT^k!>da$^@~Zty4D_yb65SIEygzEaYp z`cn8TH&6_q&We+qf~SYhsqqy0K{`k@co>7O1C*}u!V&A7m+y)f`JvrqwooS+ZL>3m z(hv*o#?FvyY2zr>bEdv{Ouuf_Jk6yMw=jRt0iLIu%!7NdoVt7AZgWc5-jz;-erWWz z1z}3V*d!D)fE|AaP1hcTv{&3VMiYN0<^1jGzu}e%3O5w_bD-6pyFU!oEfq8&o*tj( zap{@jX;kg9*QW={WjA=Wy@!gu=Q<}!x%P+wKW2yL7P2!yJML#)_5<9!C}9+=IWt3ACb6j7= z$J3ORtZt*5`mA(9kSo0$obf+WUJWits@G%ff#T?{j<48-jX-WivMuZHt1>)Zf9XfW zJ4tmgehN5?XQ4RDuBQv3G1FV3JSL35=|ZJ0O{)7$*j*jMRw7KTHX&AfHtmv&PqkF* zyxy*kSu+Z=W@8K*1C^w|l5uNNpk|AW_So*ItQ$6Aa_O^of7M7z3>`jSqy7LQ=g|12 zuzb0^{asGDj{S=fwsBv1T)5l3l6v_o$m61+dU^bp#M!iO&T1n2+yqv^CBr%_hZO~fRZ zXwrBG(vG5I;lr&>b;N6|d)DAee*_NDy>T!9wd<`g(L9I#=ksql`vwI$P}_v=-@9mk zZTw*}kaDwAeZ8OqT`~JqJda|m4Z}xQw!c`KhqE6m_O8a?m4`YpmG#B*sJFpEN|7Rv zrPEM<{c^ecyY)^h&#E9_+S+MjY3HCH8`!Pa-U@i7+Th}ID2n0MKh+EOBLbVi+#^LJ zYjJ&4UAE8lYU`l3^I)8&t>8iZdc}mYE7AZZC z&(xF-1rkpu9md*$-R72F3$as-b~;xt6`MRwXQ?l~pMr=@!!?+7k}vB{1>fPSw$|b- zXNU7^y2mM*JfaBe$W??&_VrX+_IyGMKIYgx60d@f*hG#x=ZC~elDz=5ByjOU+?dz? zn*di)RO7`QEh?oyp$3!ei7nti1zx1lU6Q6$e{s7nWmu2%kk2M+)O%6@w2lNGncZe~ z6wbJHG{07R`JUZgCFHWwtBbO8D^JryRa|hNT5eT6C{$F_X69I$-UuI!1=eNu8 zFoZMEEBK{?p;{X|~ewN?hyT0^ZPQ`PJ=zQ>ds0vfN*8EkW%0L62Imb? zzD?05loYpNZL8p7KnAeg6u?s5rT-tPHr5k0y`2P-39%ODKbWUpGCtTabq#1{jhc5W z0je&nxB5!&$9E@IOUWtH_~5IvQZ`djXoU7xsPwfM*K>)H7xR5;3Vl^3nUn~HSq*j<@tKk91v%%RnB4Na2RTI$1{h+ zk{o6ZhgEZ!IUL5-W**lZ4(rNc=5Sa&hnd4+-8sx0z__cOJq(O^(dd+xrrXo4M}8a@ z3Zqngur4s9VBmQMHQrPtj~Zu90BXCOuRzw$?Lb>Xli#5rNPd0=cn#`^P0b5VmfB4A z1RRR4UG`zs?IO~5-MPKyS>mU~t&^-Z zT{i8rGZ?5K`)$-@Mm`&y?$I4cyqdiUcTd8&_huY?Br^^-cA*_)=im&Z!R=d)28>=V z!}XS)zQ)Ich1i!ip}K*zJOg!066KMS>=`|Xz?vngQ#|dY+|Ejtlbi!!!c=B`5XtSL zl9l&Wi6SPM7R6c6Eq&TJtFdel>8CN`-6fS`;BByU%&E>BdV&vAdXru<|Btyh0h6n$ z_P$Tfsi~{GlXNzyDhM)H&5@xcYwgeZH@sq|P4KUVH6n?X}ll+hv4D zl1_j9G4nS%HR6{C^{J-+(1)RuKn$*Mr&asb(mD36r~kD0Mi} zY7WX^EMQ*C!_47f^Ybusc-UATW)2U-B$MYghlh>lVdn6#g?X4c2%}$Orf#5L%I~4p zFGozqdy&l@F_l0|N*5MtDI2vFm}1fVP)oPRGg7xh4BNVxIfA+=eYIDRVw8sxAH#RK zpR)`#iWPJDP@s!+0?r4gXZsjX@0QpOUA$}9WsD}?4Gtj4)a@9Lc1ARGxuUbbBcigK zVBvw^E6#4egnrPh4e45rtB&T~#nk9N*4N~_-uD5>Vm4DVOyhlmkLxLF7Y#3sJ~VBp z*!DgApmm^Dt?7DCE(@=l4Uy*-bV9LBC%?7&jly)K;rZk2K@jb$r~R;B_pt~b0=twN z|9aRC52BPV28Sf3n$Rci=u_N$$$r72)LTqg&b};y#O;@X)JBC`RBuTserv^Fu6Tu7 zRJsFA7w&Fut}RxAD@efU9jA>edKhQvLtmoES17kaEhxj;stw~zCAE)fR#i~&5$9)Zanzi~~-=CTHc{B3b{kZ=jFY-X6{f*Q`@VE;h zf0Etg0juM50ktu~vf?$L>-0%~=^biHBMSG=w^gODf{5vI(RW**1oBAr9&}aIJQ5AepMyS^Qnp7Z zN_gh=dP}I+;`XIvz8L*MOBY(;9o7QyVvveIU+rToMM_4Z&xx14y3G=#1HG%1ax3>e3)BTOoI$t{&82Y0+gdqjrQ=go_C{oAM=mWUC z%Y_4Wu$%6s)aeETXXTxfPZIf?kptx|jo>@&FHdIMelIlfmK1K#N=gI{-cLZ%13Vnn zAPg3pyMu9?N>@Lme}uxB;gxqEx%cHK=`17GwQ}9vem%75Dzswe*OJcmr4(|vuU87W z)Q7Y-sy)#);)Ka>QDE!MJh_7CtZ^{M>V&MJI|`I^HOv7_!gk8T%t4su5Y6j7n+H^< zo$cJ0cOb-=p@pU}UlYi`bDrNE4s&@PW)2VAB@Z))hoyO#IXrCFJj@(~<@j7;_=sLJ z@llxL15YY)uc<4x>7M7knZk-a3Fqdx+by`$P7czLkGFrRrZ6euRMC~#l-LV@h_RiO0$ zDX@yRyE?jE44PYA!+IP|X76C}o}UCHZqIein)Vj#3ufTZFVc=}`gKf8MZSvJfFdOU zup+Y)n1|PC+M1XOg?tm%1Je?+NWlTD#)!^bjv>hlDbKG&U^(K#cLEBXWr2#Hr@AKT zKG5AxWNTTC=}-jbj5Vq^uI0kjh1X~%((%diJ|lELCqwxAi{X<%-aOu0`scy0Je(zzF7N=i#Bf z?hJsY2wyJ}!Q5Mx^&<6@r?MMTdBTT)yW-Xw$IF{2F{h8~v;T+aqx%I5fd?C=3hTa{ z)w$1s{iI)K-8(|^f!#~;*;Tb9yAi0(H98WhWjEoLIX255^l%@T<(S84NJV3|7Tbrr zN9z0Qf%0O}Gw+IQM@n5${VsIH>^P`Nzfc!WhJ33Ny2CxO@c`%{+Ad6G>8w!0=p}+} zvt@b$%}NWo{gzZ34yI{fTzO6XqItn@X=t114IcX+FrKqfONd~?&+JR@Ngv@uH~RDR z8)!@uYZQW9yQ?1;F%ubQo6QT}NXjX$@Z1c&+~aecxWShijtnMPv&%6avt-?BLc={D z`lo~r#pRo|rF2bV`W^M|d@q%sKVN2Wg|ZY+)~y-!|pib&ZKO+0b{H#uE7lYg zYPy2mOy9|mj4&(h$t8MUej{`VuQ?sO?4Oq)6}W|@8?6xFy)R$TyYC{H&B43%sdnF^ z&)iD)z4onk-^bVMP&NIBmxBkoiSH+PxE^;uz_(tx;Ic}zr29c-=?IQZfAx+6`kR6e z;c0)EAC3t=!pEc0_4}wI%&No3aOL$r6ZT!8vXATM6Z~MJ>XV)TKJZptmtzHDNsgQD z3|t`^Srq+3k*0sbTY?kvxOzpLk}`~O&i}PRlFsg@R6x?b%?f~@l_UGK`LzD0pOF)u zApL9z(>>SMQsygEX6JK+nqHtgv(Mv?)7$yo&*$Md{ZBlQM=7%}@H4#T(PXb>ci_JK zJ>ZA-_!o1xDQJf&yp-fZ3H?wY6Sv;TQaIhfo%%$ALWF6pe+e)v-|V)TdvWK>cui#; zV*_8o-4zZ{Q{j4x*Bo3DR-6CaFcc7q3uklNMmroBNl8dFo(2MZNc#2g{f54x`G3hl8tU>*oOxXo-2E0m z)J5UQa_2_Zk?tzPT`{3eV^wq)(vU^PPrc9Uwssi^#OYm%am3Q^6{$iV(E>W%t$cj% z3EzA56}`SM2Wj5L8$Sm!sq}~X!SYnPkJP8yJxCvh`T=~6-(4?T*}xxOP;jz#vG z=f3<oWX7F%&g{)=hXf)hBD4>Wf-G++FUiof@0!i(8X>C?Nd- zgdb`6tvCnnh};;XfEQ=);dH_jeeUCZ+ArnHV98{-2!K#nvR-q^zla zO|u!^Lhk%poW_IA<@s9vDrmBGejr(J8-6%5IbEF-7GV!qG+i4E*eI;5U8qA2dxwh5 zj5U`loUpg3S8iv9d~6)%{-2UYeXAFfnib~I0GIJ$&LjQn#7w`=W$-D< zQxuo(JYpoEo#RN%$g8PS5K}y7buOl0Q=&oYlM^I}rdpR1nP1M#c?izlO2kmHzt~Qyx{n4}+`BSiUw^oq?VnNk?h)pEK+Yr0`Exms zlGCLcN%t^31${fpY;%w~C}GK}?IJ`@(QAcsl6_1)^%p>CuK5YEm@350vGU&({wv%g z_NsY92Kkz!sF8dcO2!=(Ih6f|upr96cNS58_Mm|LmPA;76Yt1o<9G5^QDo0Sl9vtV1B|vAY46n z#;l-q^U&toa)$u%=D@JW+`8TE7(aiAqjRG@U!Ut(zI6-6kR_}P}t5O+l5yctlgE}8)awQ42(B-wM?|9Cdq2VJz0XzignJx-2x z*qFPojh5f$^guSKew$=}rUjs*bh!_sK>ZPVkQ%9y?awDcL*zidn`_+x3J|@1Ai6gY zt+rv_7+*DJZ*T;-?;=MfdkeqD9|PkZ0mj?-Zm!)n0Hcz(q$tp(A`NPj)_s$?e-)10o;?QCc1F#0NvN%nH# z!#1*M%N>Fa3-|*8=`mzYk?5>QujFT8dt3Y?H2zP?g7hG!j3F6C5?1Z6PWlI{)aJ8JjaNr>bkNk5MRrB-jRiTXn{!brJ`Gbg46lJiF6xetq5@5_5zwh&r^<7{E*kTWo~=R5|$43}g1SiAaN&o^3K zs_ECgD(TnwV%>O}k3a@G*CRK)b@tzy4ZZ#5nha}`;gEhqC?qX(%g$ehmXNxra4tGkx)WW$mSOQ!z&07M2L-H; z=Va8zeWTzNd7G`zK`9?6CYld%Hh5U9+{(moB|DC;RnH#JFTF)wy)k`a-qr0A-?BM# z;;8*ZVn&C`K=vf0)F)vWqnieCuzOLQ=ectur}#{sVA)`hfNTmfY-j^Raupa#y-1>Qn7LQ6DzcC-7C@m%j1AeBY`*m!v-y#X0Y{L04(j z)@TPR2-!aLJ`_${d>XZh8#Q9vi$J*jO?Ats^0Pd@!*-ZwvC){pF**M-Wbfs?P36$E zKT<)76=16#g1Yqkgw@&&faY^_-QLT1yZVUr+^$a_=%(C9S}Xr1g(VZUNm8VLXGG`g z;(|zH=^e@&cU0ZhBCCxk;ESJ)Urs5SHf}>bA4yG`3wtLs*KhrD!DeIaQSDv8%!;c| z_Wl4AcQ1-N22#sad!(Pl>M;U;FX}bgKLo6iYBb4q6~#nI)MWWxuF2Bpw1&NB{LaDp z>Tbb5R59>SD^_gIHi(8nX|Ao9U6Nb+`NMP@@b6ExeTYuyR==;D1bF(&lk}-}pUg*n zWC!>hbqKj>TP2#&wsjlx@1k7Yrc8gX#^nt6r+h2kpsHUp5wEq#^laX(v<524b`w2b zN<2!nZ^T{8PUn|3QFz!C9@1z(j;RabWoErrPt&#qM!Up@H&X2Sgd=F)nTNFxG zi^i-?dPCM0!LRk(&->wUQmq$Fr~0cN#k%+uFo9kt^C6Nwu>uTZrOo|XEacZc=hOJU z*XpiJA;T+35S%ZTGyS#dayT=%I0P;}{02X&G8Sx7h-Fa1F6#NR;44~4a2$Qbb-%#% zV9g`HBs=YSilYf0W2V3UKEp$y?0F6L1{IljBe0{riDpRusLZH7@@c=A`1S*8F6+3o zr}x_tvo-U6;I%I|tR0*&Z;w-3qHJVAbsrXu$*f658}04*&0b0t5y)XR&2G>K3RpQk z4BDSSBbjFQb1rf{EIuf0lY?2KW5HU|zMnz|fII9Vvv2=FU~^qlnmU!5t#q&io1xm; zoe09-o)%DE{B3_3DDHEBL#nx9J9z^4f>;MXrFM1LCAotO8%|RLxBm&;?o-Vf)p4F~ z&N*_PVa{02r^%Vm*k|I&;Ua?(9FsekgYxKCN}naTp4 z;bP{BTDvhHPCtby&KPpL8XDw+N%{}9dXjGT&p-89Xw~SqQ#I0w)`zSQ3FD=En|?KF zN^m6FCU6qPDdQZDV3RbWiTj6IKbZmJ!(|vXkRE`+R?1<_c_cr`cdXQ?&)Wt_>gPMvt=!di*lme!pl*n81vuGO{t_s&wosQ+TButrhsH7uPQ z6>3rGEAkCc`_1a^4QpNRd*gOb`D5S@!b74U-zHx(#9Uk31ZrFhSdP@)Ul0D#hKaC; zd>0;f)OY$=3cn;922^8cqRpGmJWZ#9^YL^HkUws;SHI%^r-o6iN+3b^pi$C$k4>_< zxbtXDY>7x3jD%RH<~GMX(%5|IWo#RvpBH^Xb<6(2vFlpoPITG7&?Q?xr3WwSo0&1f zZh{kVN$r6b}uc<33*$x2$G%y3kim_R;6CP@{&g&hC}?DnPP(wwBW(>YI_T=Hw5 z@OR4LGgm><6VNv1)_=RK$$>HsOQvZRUkuU(kdDGs?no$CJitMe^C|12YKnAwtB7W) zorz#}Kqo`9LpDl;H-b0XkTqI=+WJ;rFP#Bt9ly=`vgUXV#lR6R&S4k^LXPPO*Z30F~%{oF(ql-LqIgvurjsCv3MN% zm}mjY6LWN5_y$5gP5DcQ?2aZZO)FU!ZfI%*XpXV#nzco(v-%NRw?2q_`WXXrz9(DU zI()x8|B~q|@)RXN+qCZNr`Wb!!gj5H^dr(QQm|}YZKfk|z~W=LW;(;40blf+wqc6! z>nX?ZD2i5f(=R|W6uEK+{S9#sRG{+8zXX2e8e%`IHcS^2!TCH7yf)ig@xv`XbMtI0 z8vJ@(3*%)hJP~^Gi||N9Q(2g8EhmOxs=>)l3+oU|0A|V~G)T6XBz5*-=P@mic?sT? zAM2Yq`)2=`m}>~z5XS@V-?AG!elE5=+Hg^1=fpbm>Vm-MgfG{Qwk5Hu7|_MB9U&wB zjLX3!)Kw&PLTw@|*-|38rdzGLtFCTRMzoqOBL%^RXud1gi!C1pv+arNV^+|ACB=MR z^bgibq%O1-VYNC8V%?aabOK^9iJdT9*B1Z&{y3J5@m|v2uKHvmA2@ny497G;k&RBfpdBj^s7oV<_=vsJO6V5hagT?$Lo;eKv4ofNd{7&RHMV~19i`7{=nRNb-amIY5$(yhrc zRg%^DTf6@$dfD-O#a3&dGVRSJ*OCjXxQDw2m#r`f@6i8=3Kw@n2O`DXsb60j=Tm4Y zp@u;m^gu|bv3?mrUohGWDA&Y~Aiwc!X109da`~rf*#TM|rAozfygNaZsoFH_*g#78 zNx6eoX&Z2Mu1v^Y%By85o_>6uXENIvD5l9#E7{VLDo=l0YjwN>+}g`Y+Ej195ZIbr zcO_=9cNj-Co>yfaMY(}ns3qo0w^7Tn zRk?=+4zw))@;F(XT}*`t*nMGQ$BtU}v=*! z0ZXLG1s1feiWHs?eZD&sJ&i11GW_kZyRf$q+u^qHd9A(nN4(;EH(HI&i`%;x5r_T$ z^V0oo=8&K}B^-kXq~YEjtAV%aUYx#ZxaalOn%bk>FI%}aTqb#(vSUyUcpVhPb+dtm zhK`Pt8rd?{TVsb}I_egCSnxgs+f_+j?a=&0zhZvUHG8F6UY>S-U~@*yFvHN_ZlaF2 zgU-3dfPV#i`j-&hIzcVnp`30q`Y`FfN;;$?)W|H7CT6^gwtcj1yFdtrXtDa~G7_^p zC4~KPx&lbnNj-y$5=c5FK;o$Yp-Ct^3^;^aR~O9)hg>cyh3Q{GdW`z-rx8?dWV?y7 z^=zd+6h{AYhN_flbST^1qP^c9kdNosI?&XuEnZMNKeoctJxFNpJH#2y)O60S-;|~= zaC1B(biKHO*89~<49JpnPZfuHPV^9IKRa7my|?geAbkz`R<=8JSwsy_ZOVKJ_o0OX zENpdC-E9)wvw@T&tseo1J^N3ocEi{5(bjt&*$*4?FjIQ{Gfi^gTtxRan{8g)deZ@U zw?@&z_yFjW0yb(!+bqX4AZg9L4vTHM`{*czr-HYsMB127s}HkQ(KF}J$T-tiVwkwr zdpay!zDrt3%ePlUl8p+rsC0kS4@>ii$1BgcV0bl}hM!`0OHS#b`0(Q46 zsk`l|$)@#fWQ(hBFRh1lv)lg-;h61B`L4vlGw9hq_-ehgOGxf6B=;4P3bm;8k%pw^ zkfXh2y@xKb1#*h8N06TT2mFSxlbE73ML4>XHxDxh zVH%4&@cl30oMN26Y4(@n3ln7E%&F@1wd}p@mFDw4Up{{8_Ab#ki#$vVQ9qBG)bsFO z6(@HQGF+QRHJ$hvusLh04on{sHb0;22-w`qu$APKfCOEhJy z#ZfI<7w(B_J=&eJzC&5l&&pSu{!BT27aFTZ4LhEwnOT;NDmb(c>zvE>@Q-6N_({Oh zAI7Xp^0)QS#6@`}v6-f2m-D&o%*1*2qPd59hLRXNe_cy);G2BO%KIKw~H-_mpGi%s`RXF>5u&_uk$Uj@h#s2e%w)+ z9T>D`lERpwiM^F=-z68ZsDsp-Ofn^EdHyO^lcVTv;^+6UYO1ON;^oSA+u`_ z4@ACVt1h+$jfAAievq+WAREfNbdU)OY|nG^j>wv{C6A*?Q2!6B*ox%m00&bQ!t$~D zf}m~H67h4P=CkCfbkFBQQjK3l+q`8C!Y+zCZNgkVuy-KZW2b;MW~dZOrr@%hGOa%r z@k!Sc08^z*om5S-M}d-QVK7Fj>FG4$6m#u#lAkbhYveQqF4wb*hdBP&EK`00bP}ht zie|J6c$w2oen^5vOiimR`ViKE@YsNB-{%2UA3u=1~ZrdhFZ}^H$k`^kHDw_)1!LQ=jRd zudC-+gt!lo)uyL<#o0JdFpY*`JR^|$830ziJV zn-W)llcNfq%kdV=+T&F;sA=u0r3XPW?R~9uXLz-8BS*jl$O?N21o44XDtL8ef^^!R zXNNNk#vAFQlzE7qG#7FR(R+Q89*{w2mesMQAy?*^X{sHO=t#_nLS1+j}BKvuof<~9TUcu4CFdBXl3b6gP}J6`1H@c z9h6y<39DYNsbW-`oQ`u|rahP0q7bex#349pQmRw?~mV7OMMb!Lx7V&>y;q;=n;qVpTJP+&HNemuNpHQ6d9SVh@;9$J(w z2C{YcVf}#CC6A8IubVxr_CEmc@3|c7^UzZ41!~?&cjZTO%aT>AqcdrlpHOd~pR=C` zr>m$2OL^KR9USYvRs&5Vtxo~o&k;r%6Lp^!8k0T)1)oXt>!bI~1MrsIUAdSmDTWsl z`sKh9=Mzy;jzoQVNsQ@oQEahwW0_I1idBZ$C z6rG2gUd5XALF$C)3Cl5>rk4@!DqDrDgbV!&6dPo`9fvEe&lb7p4$4)Zu>rSS^>QvD zpgHJj@!n4osoN*<+x{nHOHVP<+Zq@{IN>TDU$e;1)E8|kDKJ^OnJV2iI<1`a_&YDe5yW9SKwC!~)b+yVIg+-NUV z!cdG>_ncRtGNRLxRV$;XF=T$B`Y!;Lju3Bu7IGo1e*!>9?U~h~?06N9tUgRCTFo2T z2dK=D>$2Ztqi(>oXDMlRogFR}4PMWlMoFByGMvsIq-DA~4sds#Y zSIWvsFIX<$LGdl zbJGhIFjsxf$KqtP@{oKielS|`1J^4*00F{>j8t9D91DHDU(!D4>+Kr!_5SJldULAm z>;msK9IXfTuhfoWsh>}AGxU}(1Yj&R`l&a94e)?K_zJ`xQrvmTSzzaHiB`sUV z$hK5$m=#aTb%<$V(l(I8nc^k$MDu^rS{|t(!xJBm{a5`Wa?3fci6?E&!le33K|}+&qa^7`G+IbZ+zW}bJnVX&L$r?vm310r z=`ZdmobAR7DYDXg64}iTVBAqre%P&zdZqVdqC)7&EY_ywQt3TqFcj@@;v5&V(rJBx zx})FamFjkY3p%irs?c-!D2;G>4By|X{vD;Mq#GbV?E=7NrFSv~!HyVoyrS-HN(hrCa6W z*|~YJg1Gjn0Le}hB(>?0ar>#byDGq|I90kc+*4?!+tsJqy+j}M9yi*z+I>D>ulu~{ za?1a`)m@3Li#44kV}@0R@K^^jGH$j`%upL`3?ovka^a8)$@-HNdeI0;U!{JOUCFPe zVFS~oAXri6+Zz-~Vr?v#@;X8=4-Rp)ltBp8g*UH(_iiC~-$l*?^c^&AvxF zOkoDz7OwVIlwEa=I~15q#|lnI_4F~fGTMWI^hd!<($`TO2l~`1LY(+oe269t&k*z) zf|l#RunV6*+&%+Zk4%iN`7RkMLt&4Tge{JVQ?+)uq@26lQPuRw2O>K5>2%D4=FsDRIPLH1@;_rRrk$~!v~KobXy^()eT8>IH~X>cA*sb*J0 zpz-FyagLx_51WO2Z9j3xY?>A7lo<&%A8|qq2k-D$v$Qi%DKhb}% z$qIdPfrTKn-_fT}B|D4A=9)H%xnTTsJbDxIY`!CW&*6(2tTH+B=Ysqq?*K3W6OB>_ zs7w}1`jFLR$kmREig(|EhoN2-l5=ET(`WQ1w(G9TWl zfy-T}G96Bb4q+E)-M-%gB#Rm{eVM<2Q!gvhRW&@6j^hFmG}p{DPZ=Sa!smdx@!||T z=6ah`Mu>7}c9)Ry*@&4zYwkkMhOeX-n}?^K>C}f)j9-oI!(3qcq<;fu>w7TOtbSUe zZR3Yq+YWz?vugJwu*3}3oVe+pL_N-40X-`v`I+<;C3pL8;3ci?k3fRNuEWnfeO}I3 zZM2oEFri#S?tE>X7iHvo(DEHMkgt%cBZPNQE>$;B=zofMOvGyJdiDl9uH#@*T7F3)% zc>3O40J+g)#dpj#St8BFk{q^j&S|%|5&3X?MvB(vYu$5o_t?Y|4by2M-1c9U-ix46z9D%#kbOg

X8oeht?8 zxwGHjIgd5Rp`=JVJ~A;ry5?CbePnFZ^&jR^%eh|5PIHSo%{6q_h_x+| zZ)|QR;h7!1vX%5iY~FBJ>^x#@6s08=@UaoZr!V&I@~`dQ?^#Gu%Wb!!nEVg&1F?b+DL)v#@KUBGQ+J_fyDxh`K(lAS!Q|qF+x|Dj3tm0OlgSv)r>y@S z8N+*{BOi1b!(zJ~HN}~h?K^`xhzIB7<{-ie-!GU+b2FCROX;)h*8YPJ=TYc)5Kctp%Md)|NWv26_N)bVj*aTxnc-vtEY zEC_#Uob;Ynuy)1*>R^Q^+oS75t16ngfiJo}Hf#Fbmx#vg zXVS5{FO{=@bMwXWp+3+6in;sM}<=ctZ;(q!n^@x3@^Z-j2IMOS$IK6P=?qy7f`~ze}^(~?_X>A z$C=iJv(I58(aN;~sgT1MHXD!g z9tuYL$y9eHgerq7JB5hQpNEa-nE#M4&YuMaL)Jm`@z8ajv4@0l?kq5hy-f~Gb>aXG z194tQ?QJgv?gHQjVX`z3TcbxZbkl9H#+cZz?U&n!Q3ghy({Gb`oiuTAe@kx7XLPm( z={*q&Tbh0gBcLX%j2m1cCw*V3|0j9B(H)lk05UE-%s6eXcEXmcKY{b05V^yg?N(L> z=4|>syE)naT(;8Z)iaayJ7h79;v_2{-9^!{NruWu6U{u3&v>P^>F0Usdq)wrP_)jT z#aQJKPgIGs79P_FinBIO^cFErYs&W%yryu0Vx>i)YfTx$};H+xY?j~;~niSKvj*Rc7PP&!yJ$*X@RT!ojHp4V^GfXqW z4UF}Si11#7ldQg0y4c~xWc72S*>2IY$2iTz?>vVT6ISlc^n{`xmE|2ZU-$d_XGesy ziaWuoeILd8l~k#ro0;Ig<$)0|4O zd+8D$F(^y4`C*$mho6z_PmGyP@*>7%#Rg5%D;h@D47>+Q&N>4Vo=7h0>NX8ZScNrL zYwumL9fEgXNo{!h5~0?2K`wFGgG4YGAh}v`;&C1zs(Tea$=P&-V`X5MbtGakh_;?N ze|D5JSFiP{H2o`l!i=d4gjMdsVG| z-`4HP7j4CbvYoeC94%orTB7o&e>*VFQON2` zHErMzFYKM#pP)E(^vS+3ThTBCMw8l5Nie;zcX2JXQ8w#(YP*^%JIBkHA5C`XM0?d&=XwU{a~K8(FOn&{czW zHew*IjkMoM6)t9{Y_*j;GWALH?&PlmBVB@@QAB>TPRR{97kJcA$*WAul7> zCp$W^t1^YrFtqPiYyMy+maZ35baYs0bLum$?mF~s8opX3R=Tg^qq)xQa4m&~$T#*6 z@{I*9-&k0ZZ_KlCw#>$v@&+B7k|BrL?Q^BSR|AZIS3vU*Ler+aKjRwI4MK477XnR= zF+=__KRO*4+f%-mjF6>d#!!`d7&C@3(i*e3ll~6yFt(-|RDVdbhhcBGz}}4E1)?$D z&rly)Udg2+;a>LHS zL8dg#=FK+~j+r0Hn)!_X1>29p>R+_|=$-Vp)Yj}6TTV@UqA7CE0srFOYXPkLW*g0M zL+sa6cA|f{@VfUJ5={R-U(Ms}VkRGCN+Tvu*;#FqbqHDzEts<)#;(9WDLBraM^O3? zoM;DST|8qIG}ea99t4Q^8d#5{$+FyF^ho2TPT1t@42`4ndUlDxYzB;9+>bLQTm56J zi^Fhv_b$Mg7o{7CZSs9SU%MAzy`OXa3;w7I2%q6RT53BxTWyyY6F&C^(kr=$IZ|&- zm{l^}p`&juS+zKdSr;+*AMS#;xh&lrwkype<{pi+7f>vw2CoBqdc_Ont1hUfFA_Fr zj>+snZSj7RLygsz&R>75Y8m1$7# zldyFFZ5I+-sh2-f9aA&E&&i->OW2A1C2Y`uGCC03Q2sF}3djJ&G1XvoVJ>!@EkNyO zJp8igy-9Lm? zwoYjG9sB*X5^0ODQaEAqMf2kQv?f+j@?@cYZr^Tq!+n!xP8&S61#_}XA*fwKMIU4y zy>Kf18^6H~Y^P5(T7i2H7O4z8e+Fk}^ zAI)aVO*YVx550~kmd|T#xbu#AM**$~8Fv&Kj+3U)JGAM#d!2Hacu8-0%?tyi54mbCL)L}+z zOSc`e_!CYjOi$bwcLdq49W33p#tu?mPX-(zREm=~#O3tWIrsZ1WltLe>wQcn7hZ!X zD`--|v>Ke6{igJr+{}~XTrV7#u~GiXpBZ)HQNcK{=ZiQ z@aqHI2-bB5^kVG9zu`9qkg5&d7#J#@_@mWgzS4<*IN1y*{(}lF0~ZRK=)p9%yikB- z%`X(xQSQ)PhT?F)KHG_Z^Pz7QjKthIuv-Nq%%QNf+EJ|R+pWJYI`V#B+oYp(3Vm~L z^@;L*m87?UooM;4O0C-d6|?WZpq`Xi=RspQs420LEvxC&$GPuPs42Zi17cP+rJ*&? zCJuE6PFb5M`*45J6?k;(mThhDi7`Ous99D~Y8L7|JnzIRfk?GEprRC#Yw@!n4qk z&2`PYjsDdUcymo$H-UeeXkW!vO>NpZYraXf!LQ+uv! zv=9BTP$>HMbd7S|74bo*g0=o)dq=hXQbtqvEi_Jlxq7EO?RV31-M5?bS~=fp&U58_ zvpGL5=R3^#Tsdzx=Vb!-Hk@|$azmW%PF%K(Ug{Uz-={_2FTi^g$NYM;rSmT35iem5 z@FPqGDeji=6*}?@L*%k^?T*8~&?V_Snjx9JjKZ61D2yU6$IZjUHHzn=jcw>HUnAQO zRv?^MeAjMY4IKVq7E&64dYfU?Y>5ro5twc}s93mYsUN?2mjLWVbt}GWuXG+)*o~{{i6i2!4!D)4pttaGTj|w816>t3LS065;HD~O%iVcS4rQE97SzfDh+3&Y6cJS&?h$alYcwOypC)0g} zDl!7MDY1?`+cc}Di(Xr{5iCw^lB||K!jc94x@LAH_7i-oy3WM+rxDR>`6cNPDX9N* z?ffbVtLJqQPat*3{R3We2aZ?U*E^OP7Pai^Km_55O~_@plMg;lcKLbZF8EWu<>I)D zb9-c7-y61sGIZmR(aSQ?%J8J;2}}TwOZ<)cJ`>nUlfjCF#w9 zg4Ny^ww%6Jv>)cCrpW7h2Jp!0AG|RPi6DmNALLKbdh$-!Ye7dD%cG8r(qfOs(>mTs zq`k{Qq)!nlub`-MB2QDXJK_;V`^5DYU?j_x7N)Y=ySI)JzNYE@=9v!dmdyN zYOd^679#vAhTo%rmDmg3wq2A(5^GlOIJ}yqeS73Dh^^-**=q<5_q#L{lI*pDC^K-t z9Jaf2hXB*I2#D`)0uyoFy7-)P-9v7UOQc2QEhugo&_HF_gYvU|?mx-hzovg%E#ove z)JJ*(hXCNvQdwvmTUk4n%6f^+jN4X3Z8 zz9uQzyttlSi>LKINS<9+1iLOrNYlEDSRPr^G=iA_^~&(k<0Svx1=3{K;~%=1KBN}p z4_l?jFGhf^_oR5PIAVql;*NTF_69zp9Efx#!HF6F zCi!#=Oc3}8fgny<`2%Ny24yL6NAp7VX636nlv;MPd^$5XC|-^H=sZ9fJUXYpvpU8| z+;)CqzLuOH?fk0T{qAV$PUltQ=ugqq()^sE8cFx=aM3$RZzWGqT_jwaA-L^Zx%&}w zQ$9A8|A>%Z<}e2GYrk1sQJ5uv)pVVXoRQxKiON5W{4)%Q^nvhd^t@f9#C>%LxmV2A%AylvR*ky0e4ezNrP&>s_<9I~sV2jfkKYlnaD%pfv~D zuj^0qwsTq1CohhBqESs|ox#v^B zH9bM3!p@L|^PpZ4C>ypHQV1I&Tf236b8antvT~isPdpEW((FmN=A+BDR#PYb-I*@( zfvx=uJAvIvQqOq)G3U%?8`zernxS{ZBHw)vBh1!n<9qgqc7D8%iyaWw?E*N(!7Exa z@m(*#kCB0~WP@1*O*Z(YXEk-}E1JeOn2xENOFj{lfa{)Fb6D$$ z$797~X5KJAO>a3r32B$3u8r2U9cS?~n(L1RzqwU=&YsnKH4|-L1xzO((C%*%saaoH zp6=!GzvZ2I=VbQ-A{jJMB7M!@zq_on8DJe7r)S`bJIe1j zoMk%C_yBDQj}r~s+$j_fA;7ilt(0N(_O)li3nHy}^o#jEUj4%oXKy2I{|Vc-<3Zmt zTR?%_Z+r*dmBkabqc9u3sdQwrcM|Wf+bxLGTkwqX?0R-HdszJMQs$rf<;ZyR#N2*n z(VLMFMXxf|B#|yt)4Nyrc>9K%dXxM$bZP0HxgprbGvp)0HxbqQGu9IAV zoriLnVp7}@@a$01x6cGfSE)R$`iYgCe|Im`=b%-^Y@t5UXk{?o3+~O@)~C>M`6t@L zkLcWJ4Q1*tPA{T_b-T%Fr|{XS_;bxjoMt4+qsj;B4#(|l6>!{Ek*B6c{c2=S1Cq4` z^n9P_sdm-g%k#pJG=tdr(_6u39#5-YJa;xh^v6XCWV9dC*J*2y{JkHb-H#F&>ez&H zghom>b$i_T1Yh5KeV+Lt?49C{pfQiO#q@WT#!~`=JfH06`OQP-Q5sK4o|8Ry_Ew;I zpgF0l>jYU{4HZA%+x7{4RID%$J*5;Xl(M%OIMpq{-$X$60V*5{DJKv@_VifxL6O9J{drO2_Q}9H$?CWpDSh){ z4+UZATc;Zn?ToM4sWEf zm5uh+Tj)vYCy1>&me854W78JP^pk`K<41;(Ho+brLN&AI8qckF9Unji5R}Y~MwK=? z6iWN-6GM`aUrAgkwA_BOYVu_006(N!S8LUpi57MJw_j`HhGg9B2UYb`wfz$Gmp_R6 zDMmx>$Ykx_`Wn~A(<{^_oRz+SuaqNDnP7Kekh5E<>3F3vWG%%;;ZykIMlFxN4R87~ z@{L#XG}Y|W1O{J7m%f}N_h>70@4&jKtkFte)12mWOwTDDukzle`U z=g!87Fxz6!VExseWiYl?eJtmrbKY}&)ix1IPxcq5p977!Fbm)NJpS}{3*-#ll`hJG zx6T%L+iZc@Pu?>7XZwNwSrqj7e&831z}x$QcNBr2>IXiVWi;UV>DdB5Gh5*2whZ(+ z=p1;1FH(%1Bjf%O?y2-@+HQ(_;h$pm)%RBWp47gQ@Qw0ZqL|HFEn}{b%<19i`sJb$ z1zo>V1Qv8Hr7Y-LN?FkLt3~#Lu3swx3%a5}lT)jp>(`6Gg09~v0t>qSR}omy^_xXt zLDzoi4@cM61iF4Y&=q+J^gXHlD$!M*OB9pSm45pzibBShGh&~y^zeDcgdu4Bwotjw zphld(Yp#7gzLnlEACJoloG8I-e8Lo8r#r`MO-j z;bo5%LwJs0D#{aRUV+b1A>s|K!uc23ocxBY(&hZ&X{wV)&B`Alb5y=0`>v>|_j7{( zPW<%w#|i~u85^#=Kun&q_gi4G}=h#s1`bDK-45P8kP#Z13g~lbk(es=0c{Q%qC>&&!ShD%q@lj zJ3ZCqL4A7O?ex@}#VrcZUm$HIyN9?+b}zqd_j|X4Ykq2X3wX7^PsB!rT2y+3)FY1M zhqV7$O8c&UT7_Cvkv98*moJ*~Hj_%E&sdp!(;v!@{obUqOj=gb3VlD|()aN*#Ta4~ zNTN^*1b=u)+utYIN|MFdeO?5%&}_(Ap6o{+C_eaWvml3K7B>geP z+Y>9TCjv2Poz8EH?rc!Sifd*OjiOhJH8YfY_md}aJ(cn+59RQ<_Y)F%-oT%Z+8YRG zsDAczh}+WYJrU%CT=oQ_WoyN9j-6k>cm6o4pEi=`|$rj{_n*9HIL>; zj|~WTl71A_cut<6-UIzg$F&^^vA^u+giewEoa`6w(g=^TU&`aC#l2tkb5bV?Re!jX zRAvSYtwe7GowKNGobE%p7eE1Cn#q1k(&73@W66n!BJi|^5TD2j6YbCc z<@{G$=r9m|AhHKmru$65)O3GEo|?W5h-M3CYFb?=IQuL9)O3HLo|^72&r{Q%>!Nq~LoUe!Kcsy#dzXwypeM10*Zka}vGJbpRPlUw%m7owSB==hcD(q*W4FPvLlxG+1e zpOFHDyY~L9eS&3gDhXHi^Iyd86U+D2kxtQgVI2{IOj9lcP#RB3Ce98kRaZ;=l=>nt zzSM_NKk=bpD2=BChV<>Un4B$|^uc{vBfY;DWqlB?N%nhDQSV(A<+wA56#6xA6kWQY zGMdqel%cIo$zHx3 zCe6^PJj4<`uLTU9*axq<0uq468uz z@RIuv{c)W1{#bJV3AY#Lv#-(S=7&Ha>HT?Ta@oraI-y^qYEWcapKAB(swgPk6?YU7 zjAYurD()zal^1uEF1J0>`%51)y&D|h{ue2L`wcz-d{^92z(6}GD!}mAN@kjv;+MY& zCB0FS?l&ET^fl$|>vzudFK+)8L@uU34%xnzYOuIxTH6eiJ8eNSzSh@BmwKIBG*{C7 zmKUi0rhb#R^}Z-eC@TG+dI|cOt+y%HeYDrb_jcHz8t>A^xEsKp*-JFrdu0 zRf@)^*0po#Kb4{z#2v+ohg?V`JfzH1jx++b`n=vxD!n5pJ?;qPfIU>sX9|UOo)QQn80myg<9cP*APZR#)XD74=?ma?O4>y=u!;F zAc1n5?5=CY8#HHm&anawfU!U}fd0{^t+7$TgFv(o!-b#ITCW-k+s zN^pj*(mUNKWTl(lZ$Q;b(jiWz_e@J+uJ-lwq8my049!Jx zM}g_jz}#3$h++XB@~X&f#5WZSk8>&LBUDrfI38+X8}}?eSm)=Lx1IP6u}16O-@(=+ zp^$+!4qChfy!lU6Tt2Ct>VATPGTNr!2HZnD_3swpbT;JTsJ3+eDSlyivip4kd3^dh z%X@o2?Y#>ASF&giuEbi?RKV1&aYrz11CaDKYk;J`hKSiQwBJ^%KE^)=-8vRySGmsCLdXA<8eSN}LY zmrEAB#}7ne;LVK?Qbm|5rSB??2arxYv`J8v|K(*~TbqOU|5*NuReBo#pT++*&*7)i zi=mb;|JcEX(z!b+g;z@MYRO$Ix$7l&qvRecxtk@oWT=jLU?Z$Av;G!VCXi4)=;SNe z*uIatvV#3kpKA9IyV&`M;7TPct^=Jhjo7QgzlP=r`}pVO!NFGvc<#H!lt z{t~zP_)v5v_&f`ID!q9|7Ns(PaYu=qfqH@ltJ(6&lPS(xyGLaz%^n~sEFfZ7YL?v> zv}tyCzEuoe!*DA4!mj}X?S91vqFqr5yr_b$(^h)(4J##Z2u0rCd*0u8-l9Ez=i$HA zr`iqC)U{@EF^ncKo)!8p(7U5D)=6)KCD-6~1lBHxb*+3)VLZ+IMI_r4ewDv>x%Zc8XHr@m&F*-?(MB;?~Q)|jO5N?{QOZ~@yl{}2ZDA*{GTj- zeAU)b1$M5jwk?@v2&=wN4oZ5(*(FLB+>uec($iRR1^{;TdI(V|@dVynXt`Ne6tKG4 z1suU@(+0+BqnNJEf{<^kLa4E55=1!56haq>KH@#ruuAi~tCj<2T{PnkBy|p@zdi98 zz2j9n@ClrYl~K+01B~9#Dy-*!FeGYo(b-S2E~5H=6R^GJeA&2)HCl4>K~XVO|^&B{E_cVR+smWgwOQv-d?6Y@>d~V z?9cuiFXQTO3iUm_<{fOV(DxNrSd)HKK0xg-+wVQ1Cas)iF=V9fCWiD%WMTSZs6C%j zWuYTfxzZaidiEgy`k*0kSw3^f8#`ThZrGL7gvQ&CsI94wGbN!V4 z(jV^ZN>WCh1^&ZmySVpv`<~R^ReeF8OB9ozT`fVcTb#fC+Ka(?<7Q&p%nr?s|HQSZ zy+jq+hM&oFZ$Myf2I1g@yOj%E?0k74*Y~0k_K}<~*CNEn5vDrEdIGX@GbLBEC(v=W zEwI+r>73!DPHd3XODTl!mjua6Xk4f^a3?)m!D#pZ17 z_~f9vob%{6#JxEZ0&0p_xVg3u1-3uW&T6AVEh;^V|@o5Zu-w+=wQLO&hVsTuLp>AJ=kD}f|d#UOnPwa;PyAB){ysADZF(vk`b}RO+r3a{n z^fKldcoW5HKY>|L=TXc-nHR;K8ewZie0NT@&QdWZ(zLvSIQ5y3u12~xI*o`sk)Rk3 z=_4sB?g)`=Z)nsNK+S2=eO%91e}hkV!rXDbk}Isjc;T7;vN(3s`I`HwmF)d;3pzwK zQ9UH%7o&|KH0Cu`$=*IOZQ6-7>ae9yzfxOU_Hvqn>#?fDmZ|%pmin}2p4_T*`PTIN zJVNzx9IDZAxb^pNb#i(nPL=I7I=oVLHOmQ?82PfNvWX6n;a=-~achUCXp?PS1vvtY zpD1lM7QNlQ_UnxBRtY(Uqxk0i7z=VQhlfpfplm$mK9D^b?%C|JOkqUJZD@&4Tw?k$ zNZQBdmdy8KBBf+C2}2mI)u1`U&{Q4mMBAKROkuN`MGH@)JU~zJquK$eSgdIsza>;X zZg&MU&1?XJ6_Ns=>aMmb*_vrWJ{Cx<*3vU`TQe+0vTbmhjt;mEyti%zC*6JZvHo^! zG7)!_GchYY?MI1e1Ge^x7x2XnAZKD%Liu$P|Dwd(8zyx=FC9aKS=rsFP>U*A+ucCy zpv{>cHdp(Zk5y(_(cP#}i<)7F#%sjb4J;u#H)z9a3sugs^+>~5g}cA7t3#-weFqJh z-JuTmb@nA27jtwqfoCJCyf6E7O0&cB1|C!aSFDp5QFnR#Zgf2d7_{a-J*y>5=a*tc zK}WpH^)%?Gsh;n{5T{rX>bg973`$SoBp3z;iAy!K64-Pi`Ey0GH04N>}G{O{*2IhCw z?ajb{&E|g~%#0@mhlc#hKc+h8(l5=^D7`0$`OEx0L4R#9<|_K2t$%;3$lee1+p^=M z@z|(e^dAj(a#uvFo|NC0x;i@Id+ru*C1Kqq&^+m3p}9Z1o&&9Yc2%fF+2!@YewVK! zOIEFjK1%qsAh+i7$)daz&iN904lsQYbt@u-SXcP6l5kB8@- z=K5JX4alA@WNC`=Aw8!o#vi*7O&@Nhf4-0s43Ht9~b650LOw z6DZ*bm-0vRZ+6MbG@E_Y*WJ<}A8o&b;-o4O-i!`ty8^Q?HsP zKF*;MCMSEN^O(4@p_-lv!Z_@W&bgJ!hQj{xF*)CTEpx!xG)(Mv@Z5rZSK|QI*@lBZ zQm%97XHw=1)K8t$f4f+qcQQ?(uCzU$b=si;=iHN-?#~v*vIq0CB!XYp561MLX&K~C zLYtC8uqhZ|ygyHz_wOCp)c=^hx%^sB)qXDom)6o#qVq9|eZCiwe{QumzclDFQu?4%s71{(=nzJn52NRkJ=)hxK?YT5j-cl7LOHyS z&&!oCFXx)ktG`z_o^8phG-e&#R=GkCrW#&BF-Vr_@QyUoD@EI2+#r}*tHo_Y{ z?NqG&&!&qE&cXjLx&u7;AIyL0h5h}JL={Rsmjso78mLBq@^8b|K*o=O7TkLS$wMYv@bP0 z|G;zuCi-lFiMBa$`H>mmA11W^MC!Cd?ZZyCU&zpZXL~i~0;cKOge>iF%x7eNN z%9TvN`)O0p)7O=(Q~{wK@E(p%z^%W;EJgUeP7Zxd{_H*p5-MpA+}5fi$n#uzmYK&C znq95g@V8;1G#9HWCu~kRKCuf9CJIQ5Fjt&?8b}=J;o-r+<&Z$KB-dlxy?qG)Hjb&Y z>u!ejD3^)8OTToA8MbTPdMd}FPdbfx{uXjx+#4rpE>v59JI+?o8O#`K&;0Syy|bMm zO8P<|XUlPUc(y0$E|}m}1zR} zvp}bHM<1tzQ|+bmH_vG%OP8IpblK)P!yL7?ccJ8w*w}C>6^aelv5#G&e>R(bqkYZz zXeJJYAe?}wwrdUzf>HpK8T3y!vRw%ZGM=Wj>E+Mvf# zQyh^|F;1^mTJ6)~ozoZNUWU#>bgDtz}OG-8MYPNm~iP$ zj%;5Eny@D-#?|K)${Sy`KB899m7-xs1xkU0CDm5Dn%xoHJjZSc8gI&)u0*9L%STG- z*X{*6h=e5{^yRSb@0QmZ_F{QRThCrdYqUoo+8UvZfysiZd#^}v-a{3nm(JUZC%IOV? zs>f{f*p;WRm#-05#v1AMat?(zlKg!PhRGXMXp`qI>{P8(VnF>z@ZzSWB)tdG(d&xo zx9fm6R=3kh2UB|Fd92wx8>-F}ERBaJn%Is#m2#I4W-s1AmT5UJElF>Idl^huygwXp z)POG?b~)`dtX&tjUyL(5O_cYi1i~61 z{Y;J^qpPW#vwgi~6p_o0-vIdbo=hei6>3o_;-eLz_e?Lztu^`E3r@p2jN>%(fOqsQ zURxQli6ta$1dh=x=$D>W=`(KM@r2bL8i;{t(6C;-UhYqkd)55xQhR5PjiPI)(-Je1 zfc4#nAaZTeWT6E~Yl~!tOIy_CC2DV~ZS8GPTU>1~hA7q`%siUs&Wk&m#%$H7Ot}YH z{oRZhcyG6t@=95l)sf63x684Yk|2^O?4=lMI(1~+-is#aZcibB zt>Y|jW*Ce34kVymS%1wXJsY^<=v9;*ca%H9RMp;qGW#DPXd>H(ki?1)LA7jO1=%}z z+^Ts5p7fs#v_9X^eiJ01Zgo40rHBZwLuZB{F(oW3-BcgW1DD&k+TBIpiSAD3t#x;{ zZ+*a4?T&aJ&aU`fTCp|LZny(sp#ZxGoeS`?v$=3y zXaJ2za9Roe6zSeNGo1=5rIXj*YI!a=zS?N2qW${CT}9CdRg4B5t82#y(NSfx{TY5; z<%v70zg^7B&D7{x9t)CUxgJfzAn2XNOpVcq9Z5{KYBfQ>F?oqsc^>myb5 zV!!3hR^S0e*u=?HGVzGZE$Vc`XRh1P7}>M7h^2Jg0t0+`ibnG85L z3VR+~9)$`Q=i6`;PH>m1GevNt+VNtplE^X&?&eEwsO+YNGRudy~n7rmp7IJ?%hEsn7ZBCRyW5?6oVDm^?vtq^>05b+kioPoQO2 zO6=Q19Li2y>Mh1~1;2DzhVOYQ>1)~ZNVoi9(@CBjr;la%9%-Pj@+A;#9|VN-Xo5yP z>yW9+3=MDDlJN94=L|;|J>TaX?!z8T_TCzyDVu%}LwtOHujHFRJ@b|Q|zZz@9)*VAv|Ad9Ls zU=dbtK^Sefi4H#_pU-QNHfz^`&jN%+>7zvH)!-qk|A*jNUa})P8hxF#uO}^U;re4M z+NhyN#O8^RS28;1i!F2j-Axp^)vH@YC{tmhl22hbPBIS913fPzTHMSsX~ z(&tkHv76(yiSfGKGlO5RyWFK=TXD`kU<)Yoc_g(>>R4mMtbg!k(g`{{9Ftv+FEni9 z+`5YCiQ1uv9BwZA=DRV4bscT2G`@U2s+k?A>$ju_Y%Am-q0$}SJ`B%B5z709nvS?7 ztCmG4u~)u9?c4q;ibLJKiQ!piDAe6YP7|0VYac->x5#NC8MZBt2I9yXXozCy;kYsM zxCzuU&h)rf&*4;cf-~J`5HCy3w$6;#A&Z&h)Df-(Xloxyd~3rQ(fI^?i2y}NV&<^4 zO$=ad$9M$g=smF3v!0eq=E#6GZgPyVTIt1)F`1LO+$~M6J57&nsAmlro2>QrrD{1h z|9zUIy)Uh^QK1%<9Z5lY0C8Wk);RGzN(F;l(~uj7B@vx;SeAVas>L1AicQ>kLL|I@ zSj!$muGP1x4XhvU6TR(T@5jvb%AY-!1Zqp>Ljlk{t?(q91}G7dQNM`zH>iCEwX!a} z4`!uVTUe-S=}7=V$<7CfTH(ys{oyq$0p)4xSt}>9rz{18^g)HU4{`P9ef`&5d?bM0 z2u>5B=Gj)P3&Un7X~CQnVP|th?;cy9i(Y*?DU^UCW9vNr>Q?qR3tS#gOr-bGw!|;TE?n-u z2>G#1&b>!KtiqN4$kU3~*h&cSN7D8i3AP0e1B*ZQBw_4TqNjMWC~j|{%DSv1L;81S#Qb$9>tJKk`$(}+ie1tu{mp%aM!Rmay(LR}| z>=b@VJVC?WIHOujgrY^x_oP23tCQcG_CP@}U_Ra+cg|oD*{L9W!5@JG+wuP}_vL|6RoDM7Z<0we zEQ(+f){Lm|3=lTOgiRI!K{g>Gt~g015D9s4-UJE5Ag;9)wbrH9YE_h4*ScFKdcrT#`Wai z`U~lv&knbf1QxW2M#XM{yJuY;(DpE`mGJb6;Cp1N;E;{lHcm&zWNN(>;8uXWP`2~- z2?UtdYP?20piKg954AY3!;E+A)j|^!DYYhJx=!q&tZff54sF%8f_v0EHmKd<{c$&g zsT;t%yI|w># zjBMlVNYq|~xILvoMJC$ek<8n0*d2JV8q`Z?6PZ2{0PKr-A7TV@3cgW~`#B!r=a{-9 zZQu%H+7+5F&XWxVUpKNG%nS{b%-KZr^W@gwK{AGGHSGH#YghM{rS3&0HnDL_y-ODd zA_$vcRyuD1-}-|Jahz#A!JK>!7-hPnal$jE8oTX=@Z<2aD7uXYP$u7Q62)FYhvXUkA zwJJbksVhMzDmS=Wm{P%K4W0r5j?hXu;-+__VlSg=8oay*Y96BSPqSxQ+$CtwK-M%r zrWFkU%z&opVvu9g;$A1&V=Yjoqy2(;U`f_1#ep=?ZXW8v#G$bH9!wkxW3jSN!7{~s zUq&)5#_xbNzGV_9()-x0P}ed@DwJ}mwpm9FB4d$PM7qN`Y)zUq>s?e%kmy(6&|f98 zeC4jj*r-1D0G9-?Ba2x8oe1EZ{8fm1Gs`BgFO1d4g1)e2LRwMXK`X+J+7x;COI0d! z%$mwKnWHvK!1Lwe^%Pos=E7MbQQdrt`VcxPpk>n+c9eSyeo3B%Auadtp$Jt3zoQ(J z4~B^{xLD{p8khuEI9YHz)CwR6E}~9CijruTTWuwDq}IV+y6C1^EQc4&jaUjS&Mv^i zt;CV+Lhxi@p>|8PE7o$-@k|bu=;8+&goV}9QL;z z8W;sbub2$)6w~xFOekXiR!tD~lmMLD*@l@0t*(*HbZ#WC#nxaD-%3C4pV>Axz@Zac zdL*3g8o9$qVks13DSp!pyCtiY!P)4{mk2@tqfY%A;=KjsrbwLg^3wF4Y0vVVCi@={`pp1jP`SPMIc zHbUwmHYRd}8tqXcx-Ms)O4Tg^>?qNu@O-r^%YBg?%V%65dph0nVdz%+rF_N*ICP?X zB%JOVoEHeme;BE)b~^|QV-LEmrdwmj;GBYTk&dpL~tw+Zw+l~qNoq<%AKW3>j; z02m3KES{4fx%xEIwAaDeqjX~z+l=)DbL3ZIW#H_&aRZ*c%J4nbh?Rx2Z*jSRtc~=P zlvyX^J*-?`eTpZtLGM#iFBO(X3M&rF`Z#mj{(iYxH7rp2aX;X;0|NL6!s$mFu?>BAt*f$O0QS1l=qAH}?+1}weZyJ408z>DZYWm=6%&5JL2pN5 zQs37hojbbI74MYZE>+c?RK5~xF1U=D{dz;0S@UrHd`N(l-(BXm19RoEnSRN$wsSZa zMfnhl{QlhBhVe^Sew*pX$~-!MMJ0+$2yl<{>x_oNa*-6zKDx5tJ&g)G%7bae^-y{D zsp5t>a-)#GODC5;>@`iN3-qvAw!LLsaAzR%fwpfR-Sx%;e2BX{8u>C(vj9yAvS;w< z>CWImz2}M0IqMR&4yM$5mq@$R8*_Uyds>QIZ$h;)qov$UGo3;~DlCtbxeWsxSH5gT zBGyy{ZzYg8jpjDAmu_2AtYHK&EYLaYAd>X$(=<(B2JDrH5lZNS3?J67*oW2X_e4D! z#U;=mFOYhB4$``-I~lqy%>Pz|CDv>(9HV`(X2FH4YgK-@V8E4MaUj3q9QkqlbPM>q zoBV0#Oq!Y4YnK5!%)u?_FomhpPt>%q`-U62`9eb6Db*VZ$^2?*>UkjA^@udA zZUI6{Q=>Wn=tV&9V&345;U4yoUn)bUK5%2lh4hAC?PGN%0Hkg}3_V9A(fnQIe<-zy z6e)2=qeBt;2GSmT7?-s|9kxW|x^(@Vl3omY4`@ZKLFmKiH=1X=U3QFl%MH#(|4Pb* zovs?3F9v!2YKHp(65L2AI_s|O{k3qIDtaj6xZcKIqrG*D-Q=F!dq7)y$(Ya3mbf@* zsii=o_}CFdQyjFbQ5u&#%dAKq0rS#~eK)Y9p_1uaPH>sixH*!Kmo= z!|aaD_WjV+-)RReg!3pNA^&4}{zvG?+3M3+Dr{wv&^86d}{HNvlvw8m0^ZX~f zexLtM3iv@}+xvdr-$MJ0vmy|P=^Vo`!UX>=Fp`lURBY;HQ7NYLZ~8`VX1TCbWs6_-2pbMy+OHKwOvRxa7&^ni=!T%O(lGn> z3Sjmsx6TyFD&HlN=Ld50?Cgb|IM`h*g{@h)hXRzB=Mvcm^&suy#W~?0+ZHej_C*pFYy3iQu#FAf;m^O8q_V-+Uz?hP{ zgPDJ|lPt5}irg<5#U_rGPBePxr;k6!>UTRZc91Se7e*kLO zpehF1+kKB?CgX0@q|5BHiJ)E2&2SF$^=dhYKP)^_W%X(fIjLJ`*#CmIv7UN$2irZKdEttWN6KG$uHZB<9(p72Eh0xLB+3d2|I-ZG#C3V_3L*I=1OJ zJjQge#^t8-!91g*%1?(~{G4?D?pan%N6D@L*${~gSk*g%aH~TetEC#_cx8k#P6acg zsp}B4x}Q}|UK1{_eaFO&`%J_5J^A#HuUGHWZ{Uu(%wxMM*mSOJ_s~7sKIL$QlBBnnukiVsW~@b&rUBOnHwmDgTYu!k% zGMK*>K1=hnR+^u+()_HIx>;M9pXgwbC$7xME3&fuM9cCMEz3`|EI-k*fk7z?<7I<_ zGO=qRYK6MIt;&_uVUU!k7OlBK2?p(BV}u^tbV6=WmoMMdxdA^#fa)jqAP1YDg@ba{ z&$iqcPx++QFd$Hf2Rrs(hN8q7x8Cix7L=;`1$S#< zS4p_)^|Nr0HMXgPi4?@r3QK*-ja6E?4L7BQ$e{3r%!$g7+PGeFx9{WRXSL7If#4^w z1JXM}he?YG_GYe!C{l~6)KX-wI}+q9mjpQTFVYecu3>O?M1p#mOQKLOm5X#PiMf78 zSlYQH$}979-7WskToOlvgx2k~2tYx4ZNt4N$3IeTnAma4aW%`a+&4|R=|OP+^)OX% zRolkr6i~E(9!Jpuc^VoWm=73~4;Z{{ir3C)Dns%CDyfs08_i3Z(T==4!MylwOX~Z6 zzSmJ8LBQ>k!;Miv9`lr=s(Wqe3S{~EHVh)Qd!4$80<6+{v!2NYL3f9OGK_t{KPcD$ zZ?W{7BXW}%dc;{`a3jsRXzvI;^tA;WeKC0lbT<~#JvoQ2 z_(1oJ5M4&{=t}s2jhh$=;~IS<9f7mY$8*d>G#?lrodq(R1j!5Y;&|@>_gvzhLc#-_ ztKbgk3^gn53k1S-(n|ZnkozLn%{`u&E|5Pnb1KMS%R688d61W^5xD*z!Y>QBmCja; ztU6O-pyWgG?eiHi4#-Xj$zr~W!A;fKB1B2^+)#?$AYM;IjID)BCPtg;`N?(IPp;|5 zI*;=sxU-C9T0bU@pnOjQ(A69J0$@RJP6vp3V_(Qv;zRjfgLt0aFp_-{u`4tjl#r4YUneZTuvzUgL?!}regCyM_GhOkioJ(cAC^R$Q15!Pwt4(p* zH-as936eqf4e(n^;Y?-5(3RLC@cLv;S8X1%*O7Hs}SOxecqu*BQAqj1b55dnJ(?1uzX_8Hh3OYc3i zAJKqem~&Qaj@ydm{^&o!ewx;0lp4lW*fwxEoUuCYotFJX_Rp9(>k2$I2u!n#zn$+V zzm4ywh~V+@&*>>TUP<2zAq&eaUoj(v0f)u#91mSOmNS|I}Ms3({`Q4xYV;~ z5+crWmlxhQ!o84BA^)KuE+_5-6yevEx9~hbmX>Lke@Hg{ysVEzQvYG&XTd%Xs&cR! zIA)^1{d)7vRLMz3NA_HB=&Co)jpf5Y zXpst`yRhszl0D3!7F*Ro^RV4-(Ml+I@z5ZL43n!l%CzPJ-L0PkBmJz!l1O_V-2ORo z;|Au(!IifX=gizV7FHy2W1V#zULIN8*O`-^;9wz(IQSsDkl|Ud9G={8pT_#!aJd34 zOaT1N3-UA|oTnUkUY>HoLU{_qca*0BoNn?I#=#tSu3V6(aCmolIyA^r|8Smi;CXq< z2@B;Z4Bt_n3UIo~Qy8baJcYx%%hUWIPgUVO<-qguloJ-pQy9LZJQd({lcz9FcX6Zc^bIAnERf%M?(Aq z^8Eet{8f4WO3&Zow#|FO=(&5gB4YeNdj=0_?~By12(%C{wm%b0*+f0iavKHLAMyNX zxBM_^!{Qo|-$ZFa{HI~Vt!rVwQu`vs$Y#t!njrrRK(IJC2N)VU3!wwg;mi^y;1ms0 zznK2TQDgf$U`q>!BgXJviV2M^(E)IA6Y`d*eLcd#toG;1)Y&&!-&PgDhI*0ka z0eI`BDCMMLFx4!%MtTuUFw>f;kiCYGbkWA9KIA?ew=sO&94NNF*t!u!Ct@ZMJ$&mX zxXp-jGhW&A*rH_kEVh3M0M9K(4IUwR7QC6(UO}h>6sC7G@ z=oOSWcfcX!{5+OR`-n*Bs4@lnPU5QbuE2RWoX(L_Ak4!=j8%?-&$NDpfEt`T5JTaKkD$I_~j zEu|vcp7M!7#U8uP=olo}m_2Z@%Yj`E>~a=0OMXi^i&_f3e4tn8eYfc2`o7vC^?_S8M|ykmAR;6Bg%#iEr*&WgatwPyZUv~`dk zPM=rR3}Bt0EC+0yf(td-xAEQwiJ#|F3x4>HIV;ouFF*8;Fhq}GJiHm@w@Er@yd%rG z7vixl6n){|hZ5&LA26H#-o?)SK7{+ibL4yhBJNbq)ITB>=->HJVORg?v>!ks&_B8< zZ|qAMXwj}A3CgG zE9H9Xen^0S=mQRstX{^anYjQQ*}nzX_Cu856@XgoG<*8QxODRmqSowM-yWGfu%COW zOAGxsTJTgKlWTk51h&i_P;fsM4;{P+nW5scnkaJ->ng;n!16yun*;OhWC=`UZ`fq} z5#mTa7>N6)kA^nA1bQ2PgiLzZV$rRVSXzeAjQR;br%fv*|s{ST<6K7#x;DsG!09qV#Dde!ZNz;X@XW)dZaNjB^# z=~>6k_~nXNE+>sfKBsAxX(9a{zYI$af^LQisugER7SSMc99* zoDm;OcTeCo3-TGn>H9-w0Q?O< zI1PNz)Zn&r{t?ar@f^UgjHgBoevYHKukdBokLp_cPhbgON}5y-m{}3EALm*e4yjOw zXyXqBoPW61ADH%&cvMcS^8pq1Q-E~NMrL)6M9>s!Z$pq2MR44zf?o?&+NPX${xkWA zMF&s8xDVfJJaQJbVK4l+49QhdzFC2ygD1uD5*bIUcbkM6c_Ug~JxNS4b2_kQAWU(8 z801R#-Z$EC2-A2)(|`>paTYUHSh4rsFj(}2)saATbxrkdHG@Hd1OV{(B#l>dXmGax zqr~v@X^>#`?lnWe1$lrI0Me*+o`xhgQTsV>bD{gb$bDbTH^+kFKpf!w*n^1!uz@%n z%u9M+10RJ`Db|fpZ=A_SGWN50SkK`RdyT9OD~`Q}7p)4^WNF4~uu6a?O4#(YqIoiegs1~gU|haXp<{287e zxE%Rv5ZA2~EH9kp9-`r|ARN~pP@a1j+bd>b5?%GbpMU>BsWIL??}@%-KkF_~0w2pv z>z8nWiyQbVwtl5>v}2To@OP7fAW!E`I`MsoU*L^Nq@QAgjfu9RMCLBupiBh?$FHvg zM$~>4e1+_AiJYN+lX%4rIVeD6IS+|g4=|l2+CL7o9;fE13j@atG4@1Vd<%3$+%erM zhtF>#Ik`v@U*Lw*eglu5b<+{2Os&Z;P+Zt|@gT@cqlgpDyWzV7?yfmj`f|G%fXZo9 z%V@bUBDv6G&ZF*rjW;Nisj=bFBbEd9(TTA!?KhF2Zk4m{M;ekxTy|^^W+HDP5C^p_ z#)v9EH-aD7EOgp|4V%UIcnME$)9vnldrFO5RMW+lV@ zc4D)8NLxUj^>Zlt5tgsfA`Y;xM#kK$G|tQUdWA}l^sp{Kfc-u*0zdn_kT+p9G1z^MbvQBmj^s_^%I-`YO8zUN$f0DW z?|nPgqxXSJ&+~ui`aQh-_dHG0{mS~^1e*-vGa|y@M}Ta`$D9T_4lcDvf8G67?T*3+ zq8(fWzTaj2_qO=FhD_TZgOYA*E44p?yJw`#dKCe^%re={th-QY?8p8_4xkc*Hkl_1k)}BrE^>Lq!h<0KV`AV`0sth^ZMVElQ$Na z5zL@(QtX2MJ)`cle~k?c$iu1xEnz$i7dGw9LFeoD7TGyGV=hX}!t`5z?Vw&f+V$M!v? zv%#f`&0q4zDDFMSy8Bkt_Alteul#1KEMAW zxM$hKy}L@*9{gGG(&BQopOKLAfr3Iuie2h(I~#w zt^w9JW5M`5neyLFTA*Z7AvSly)L8^(!zNqTsW8|sx0>N=S~^9W#jd^KcalAN7`Fp6ELGS znSJy~O~mVUyE>))ypIL9wtBS43)uEO*fUo>dJ-EMP5-aHlrXIlb!Sr8YhnHeLYKw^ z^%L@KeGa+AUZVhdsDwZB<6@VGxur~0sTYPuV=3E^oxyy_zSWS}Y*C_!JqY2_kwf03 zKNbZ5?q$Uy#fbAcB!ml}oiF$fY{^8e%di4hqNvyw^pJCped0XA=*vqh?P0KVJdc0)dzF_}ir1bB zpYw%i2|^*KA*THetS0z-P>9EQt!}3*@?~B#GLwlfX`8$=mTtW z+uC{Iwsvk#TYE~kZ7p?uDtP-s>744)nUARG11t!WJ2Z#fX$9n@9*`bI^rg}}-KDoE zOlV;ap)(2yX?vx7{Y&Yb>C!n2QNh=eFuBD!DweQ$9%`)DQR*u^Vq#8V%2~!Oh*f6RM2!{#f<$y8DteyOd!4jcq#Q1*}5Un8z-3wxAmTSGaMme+5d zEgGC_6Q!-JRXHvzt}jCrG?GIJh&X#G9Pzi3Guq8boQDGv;&uBCz@R<7nMK917ag9N z_s29|yXNWXe^kHDa`mertXNBP6zls1iWSz=|07P+%b)zXdTw#~C$f zz`T5HM%?X)TcFDkyFU`pmBPLob5wUHTCIItj5r!mh`3J_3Mu7W92K?XkrL5Ias{{O zBN>ZY2O+hnYNf~9Xhi=8ytz6VwEwv}S)hqwJ;Yuu=A#Dfu}F6)G)|>z;LLAz|LpDL z#MusZvv<*{O*;03>?jOI1wJ-%UQmUBCJU z0j zn+U5>FxEPlNUw7B+7SfF>C>F64ZS&stBk69y!(*K9sFV%s>^S$M&U5tYl+ZVb?*=r6@d3!2AKeVIQJ|5 zV*7H8)TNyhhWb*h;Md3h53&e=?`M{C;&Uc0h|df$KJ-xNk>Rj^6ne2?e?K=o;D@pZ z=w>fe$)I@YGU#I4nKTr^r#R`dk~^5 z_X7fo_FxHMMInEIyoLY{c~vthX?qBuyaeLOt1Kk1JHrwo_U5BP5_vitN*bGw4uyW3 zyvjvh$Ash+2MK%$0neyB?Y-bsc@32yrV$lx?Y-eFlvj-MTK43@Nnb1hO?w|i3FH+} zwD*+&PhMW1lzsVoS(7&vvFk)R{s^Uv2K@m*A;$;t0-Wve*{J>2Ie3WQ%n*ZDA=8ig zLQLxp4B_B~?Hek0tn^_1rD5-fOA(R?wJ~uMOWkT<@&jXEOn60bGbDDE+SmeyZ;j!B z>j!*94V15WSwBM37@&3+R)*;lfs>tRsdYZNRJ|Q(>|2CY*&IHWBNZFNy;$|IX<2X^ zu?0fTDy&{uV6F#CfF22e9LbekSL#nsfyUWqA*7CD7#GNMyK*u&)^Fqe5QKl~GI|aA z^hNrmm&$YYf*Uhyk!$EEvrY#Uh{aDv)&QI{0mb(reU<`Y^};u2h-|IJqc5z!kCV@v z2#cS!*&#-s639$KDKmb4Q-p>rsoY}5(Qx;I+_pskle4G(F*H+hg-vk!mJj*#D6aDI zSEBi=#APd$=U9l1EnE2L3SH&a+29>Bi|A!TQ#{+krTpG3BVJt{-FP2FxWmLwlb9Z# zVFeTOy!J~F zRdyI^5^Bb9yz~+($AXim+V{iT{uyc#tAymuqlfnAQ6v_zZ`XP@FJhxxiztr)YW-Cz zk%#Nef$q*UGc`;tGXhTw_hND)9j6X)n~?nsUKXZ1N8sEwkxH%YAmh3JD{e-^4gT^J zoHAz=JiVg!lZfq-{WnlKfnHu|mqnlo`Mi^#%aNZx!cQ&YThD+Kxi}Tq@e6T6%?vJ7 zh*`LAaYT)oQ3ykK!Z(pTzSXUKD^ZeDLb#K4EIdBnLiXGFjv1GL?>&U?apdH=fba1_ zoKRd8%`n_bNWKN{X_2(`A4n!zY2OE}!FhLvU{yi{tFal+g;$8~I|l%Q@*t{x7^0=2 z*hNy!%najLWSaBNB5HigAv8a*-pou8f(P=sJ&MV)n1f4kV%8C|Zbw}lhWzwJeqgpS zw-Mt$yNau6OdL$j#b8CLq3DsZAgP3T^d|!ew<`0wJvtRH=O8?+j(o~tx&y}yH)dkdVo$_#E|Rg3nN46M0tI^!>TSOUp0bSuWcaj)qRZww4}gp| zVndjJr}}l!OJ@dB+(f7ZSx16B>nJ>;+oKnAIOH#8TG&sot<3|e+# zw|5EYH{rot=Q{K-?L$%9xtpu=cnk=5$(jr&aJ&CEP&MmI#e{Cf>Sv<}%C!CHTi&O< z0uiV#(Jg&qm3>O_v=3xIukIpHDR-&hleD>1dI%MMR#sZp z)FS4wpc@UJU(Suz%jVq$eS7zDWvA^~-`)D`1_s3B_t{O7@4I`S-hFo0 zDYCwO`t+$FXML12$ZQM}n)u*$T(HkgS9zOGuzzh3M1%lXMPnYMJRTk*@(=4W)SjAi zO<71!^*I^+2viDhHTyF-u?&Rm9~C~%sBUp81t+k%#l|equYeBgeyM|@gJxzHp3`7t zG1omC&g$*5Hh|NH^qKmxp$caXJhcCZ;GN|oZ2#xNk9q1cqX}dxL0?J5qWrd=Y%`mQ zcikK&vZvBjN)}GHkH{X1=(v;>PkTNd!!Z3Xo(1q^7c#I?B30J7u}3_J{S{h2GYrQX zmh>pRei~t$JJ2JgoyU0=NSOO#Btt>gv&^}i!(uqcUvHrfMC{4X07UfUhIVWvAZ7*| zQ;OY>N^uN60<`(3!SbODxzRb~m%E%83VVs365SZ_K z7u9B1z#sberxDfT3x2f2IsPqSKj>cve|Pk60=$6!65Jz2S!WjGnOTT=A30*-^A$?> zFba41wRkSj-JFO~+^V9M(k zNY8DjGFXmO{=@-#LB5sG@9M{VwL9Lx3^e*;kefH8z_$k6frFW0V8mVm$trW!yUahB zqcBts<#Jx4iuFq+P(F?I%d9agqzlTH7nRh;@;Yvz>t}zCVm4(kVjZG$0<1FuKbXk| zKPQ;ZQly&2Trw65gtcL2hCbc5lt2>wk!Ga+NG6uqju0M3=G$ct`1DOAn`VY&BX$FG zvWEajD`FoGz%bk)3Y1EXysyNH9xp!s+lj$A7qh?|pJ4(LtUwQX%6E?H^f?4Qi-RlCXXSgmZM>S3t_-HbCs%;Dy8q{~I80 z?(`cVRYuJWqc^Ca+*GgRnkDNaXp2`GvUY%?Ry`I6@Ha+e>d&XtZeIkBbptu&lhwww+%7A7Yb?B?I{g8B>I`Evuyd&3~36aJ@ zgC_VvRrx{V{Gk5%LHqkb1M-8W_(22ngJ5x7HU{Mf)%rn$^MlZKxUq)h2cb9Z2342m zh6QaNvz^oC!Tt&?XzN50K`~}oia}d44|hbNI@(9zfgv)UK^WIMVRPg!vUxpPQMX>< zN;4oKC$N6w~4%>@^uoXKB13e7gVZ@FHMs7M7!WP0k zn%QGvn2$dk~Jd77CP#GbUag;IV&3qz~ zXZv%c80vrg-?fLHOup+IWiXCe(;dY!->rUbCaI+Rwr5^~*B*115bKaex-;)d3z%915G@!NdU=_Hb5{c7{}4n!F#Op7?q8 zv=IgC+S4XD1A9sz>?vEw3a1&KoIZ9E0NBu|d{?PjY$zjy`q;2ihU}b&jTBl=3lOp^ z@h~%d+Nm4Yq?l<`J9>Yo8Y{)v%eYtXMGZ1Wif{cA}yWOJC)z^`6!OcflYMTZ@_i&XrfyGX?!x?7a~i0$4j>c#i& zLPg(N!o9mx^K}q?;3rWpGB4p_X13v(+XrTyn1KYm^TS^Jqaqatp#pQwZ6nk6)J-n-om^9V?oOTeRF1Dx56gG0|j|7Z>%=pP+|m*{^)?xT!DH=G~K z97QDCEOQjuCcMlH@iD(}3FjBCMBez7s}a)gy;#q_Myxp~3;E1m#5#mdDr3Z&3nzy! zxIelRBe^2IU?xqc?7Q-|R%5KyiLQE)b~Luqsn^1SXA=lye>G;Xv$q#yfWt1exM8-^ zz7cqs&BVro#UN-cWoCdw8%O-1a1YJL=k7yOBOMls6ppiZK^*2s<18tNQxbgR#N|2C z$u#PzHfBW9vzSy(L`75uctoVFU%!foxGYkxiAa|bnNWU;<&ele;78?vI%drWUJq=F zq+D|Qr~8s`mxl_p{w#nVa&1hhoN(!BmWiNxRriV>RleNY!~eD%qbcqF7!3u={rM&~ zLR!o{!tMr31ND<7M~wftN_GExu1%X;@$SyLs`Vd+4(Hg7T+c;AT-0L z{TeZ4O-8)0s~7wJJ^QgxaQU=9^l`=eHy4-V%F`j_VUP#Df$2qD#E235VPM(sV@cZn z5H)4vQb4_LA|@bO=QBVz5h_8}Z_#pYYzQGW5~&Spzll%@azDtsJ=(;u2*i#ZGb=a& zvIHnv4^eVQAryIE3>dzGcNkv2CO-@!m!<(MxE-n zN!-?Pz^j4HCq3(Ucw(-{%#b!X0L)bfi7s^>`zc7Db)Gsl5dD``AZj5Ee%Fu;+wI6* zkGhcnV?<-a({m5g>cG2~SuQE{#q?-7U?&2G#TO=YJcl_c_(%QGALe|Yok#2%C?q{Q#41l*9K*Ih2D+TFDKpqL-48svfvy3d*szu> zd*g@7MLBAFu@x)=H4 zp0Cr8UXA3>feb@!|6Byrt;7RuKZ8)lSsK=p@W`eKsK|EWRfpMVezJ*yW`+>EizsV} zQYlfTA0RaL6@<#=5>v6w42g}qFBpq3W`6&Gu+2Xz*7>)fO()SB<7P9{f=o^9Pfjw; zbh4E(Er$ZdH^B7O$rr~W9FvYfo-4sHvF&M5o`O-sS!$($7sK8z$(DrUJ898u5}3%R z0Pu~KXqGN1FP1Ov?Z8}Gv0$;Yb83XgfxT*g>W>r7(Ja|CEnx)Y*;eqZIR8MIfi@0_ zqSHsxE&xYRqc%QJ5p{3}h0lfH;$)+ebmswaca`>sY~0Kn&8`9w*uG+GEiwcXxRQR{ zQP+yM-lgW81o>s@S17)`LV>bRh%T@(QtD>i-egZ=MeQzxM|g9FepVMP;Cf0`KV2?3 z_IjX0JsF^@TViU-^%JHjT++B6{lkFg4TzAXU!lB4 z;bib&X91Ua3ex4?1>%V9UrprVY@6#ZcK(8WKPA>Ca*n&%vTHQFov)ItO*E8E581~L z)_Grm{U#)8#Y-W`O8Y&y&0_m6c-eo&18ll^-Ob?EbN)r_jo@eEzHp-OPlnqX#n|Xb z(p{_WQ{WbIHD+cV(shgFRDiSeD>P!C27rz!E>)2BchqfK$HU~~J_m_mjRR@zw+s+Y z*oUj&Cv#Js51P0F7FfUBrG3F|4;iC=!xJ zgi8xioU62OFG|$QBVjmIY28hjo7Z;{T}2lOM2FT16%zcC4+@fXVo-N{S1R8Fj#tiw zZ`Jo2-UCJ(8bigKk@{p$Y%=`@52-LLn*r80NMrpjziXYdp&FaIs0e4e8F%x%3WT6B z>sdC~UxXTu1b&XnOGu`Q7Jv^IpmM?&2q60o$)>ce+~dx_Ze*(TLxdt3CL$@hny0ej zzREAP2z}en?>S{bcQnc?V$*2h%NBg~*w_prZW*CiSX6c+PO^BdbP~b%YzI(_<;hDb zJlln6EXI1OvRkCGD&f&&pbHn8(xkcdp{MjwF>LK4*e+8pBX%pQA@;2>Suvg#?njB% zQ)^2HHlKh$eb?-^{9Ye#$b+u#CL6@3@WMlYB7CnsLcT&Fm0d$e_$> zohulBLpXj5+Q>6lvY9jG`8_=COLdQ+mj>I{vj{(3s-!P_!oN@W8M$z_yFU(GYob)f0SQp9j zV&a^gi^I4-CVX=)ocXy#V*P}n=P)!Zn@b5jH#ZJx{gm+Y6#fIRoyuNEN)_4b`Pwsk zBVX1-G|P}{<_36C|1yGKP3vK#h1Q4Z_b8PcEjaoc1>6PrLHP`9I59@N;Kd?2oWrahJ!KB?%BuI7vKQYK zlkOJpP`%lRo`>-}6~DUsC1m)dpUJ!SNLj!<7#@u6jJhiYI%Ue9@}4+}-GQ>|DU%lA zUB|vzS@pC@Y(LAYk5=OBZnfYib2AAz(8&@>nN{w)zxy8Gz6ZMRLGF97`yS%Ht7ERC zN(!Rxf3V1G_E-1Ia7V32AtqURM_QCs-9rNY9l#UsCiVaY-yq<}2)>eF>k&9nzU0p> z=9*~r@M)(p5R=il@S)RIcLO)8dnkKe8(Sj#tH-e{_Z5ApT)r<3rm$pG4`c%2Aa5A2 z+QVQuEynhMZO2qE@{tm?=G5xAIjI7H)#c_Su7+SdIVs9Fc6}77P2+k4F87ze>gnc` zGPum@qo(3BNk(k=0{|Z5| z#le_*JE0wsfC75i#?;FRJvjvZrW(-i5!y2z;P!%hDwjUu9U(AcR*6Uw6(A3W$cF9OOL&^VV%Jm^!%-&FRs<9~J_;oI#KaK3^#ur0UYjcw(`dRnkJ-+CB$84q0xCLytL9VqU6 z>z!~0^R4vx>sQZ0_ql#`H-K3_;J%0MU(xO9A$WZPh&2PpR2kUjW?-HeV@(pmSPU7K zwX7c?U;ut~XW#)tDd{*rgf-3n8knYo)sk5DH*{w7$u#T?PY)^sW`+=R!@Y!mj@;>l zT1KL01bRNm!OjW01i&rucY$r6hu%x}K|(7f^|}YZ8ZZd5ThWuq-ltLcviBtR{R)tD zGxSV?zF{B{0CeG;mCj?EXu`Ixp=KW-jSQc%OpgRfKYItkRl-PRkJmPmfU@OfR?_~~ z%qsWL_t?a--_Tq=M{^}Iv3~?<=m*MOzy*{x1yc78tW<@5C?1ywBg(7jlyLtI%!>S7 zk5b}~gHZmV9U{m6n0DZph{4{}0im+Sg-Wzoh$X)o_aX>#^s4BJ%w1F&C4-f$M>ANT z6Qu~$G)pbzcS2otk<7}Bg}ZmE&O%T>7>5csO>XASH0 z?vNLMA)RKj1v*_HlIad~nmlx?)6g-}+|0~V=K~#N)_4btTO1Z?H)czOeWl<+(O(8tC^ys3G`6pm! zp1=c3I*f=ecla*;n~)Z!4{qkGcX9TYd^@+`nZ1?HV(T`%IB!QU_B7LH7+45~*jGVB5tgO4(s$Vep2H zv;I{T=+lGR<)!u!n5gCVD`_~(%CDY@QtXS8AcIkCkE}(st)yZz)BZOrpQj$NJTdPj zC6bY1l4wfWI+I2J6=zYsvgX}lmqOPkkv}Ve$rbAbAX(UBF#?~Mc4{zrij%2?FM!j` zJO_0U|Hc>L@@DmM_fXV%5Zr7cRD!G~M6wwvVy{J#)-pJiI4*4*Vc|wI4en8Dy@VvA z7VOlBjW30$7LjTSx!pvl1X<`CjIajc(X$la(4z-Kml1Xyh?njGEAc!qt>1zZdjdiB zG^UF4vm@+>0PH1mo#pn!aC1w0Y1H0~w9ECTrT4_@mdh!Na&J=o1rUr{gP4-f@-Q>= zEWo-MVUH5~5s<6rKnHtqIrZH)ii^z7LKTb1a~ig#poXFc8IxObBRVy{2cTg>rS_S~ zYfUcbcOZ>|Ronlrv3F?^*C(LQoi&(#@3%do8!^V2_A+F|xmAbon0wLvs*_Q!K|^U~ zUIE)~f9}t42K_nu{Ppv4SpYRNSSTvazKTb<4`(6}?MlpG$7PDxKt@KpQUb>KE2Z(o z?@G8oz^~4P2L?^jFf$}*&*ACeH{pW)CcN(VKt%ZwWFNx7*BO}Mv-3s-)t^a(Dvt=^ zX~OL&774O%5xFA!HePizl#+llgj||^gTZEouk6co_ZK?oQFZ1}B{rt)`NEb}d6Eq7 zpSanydLZLoW5nc@(g2SVstg+=$)sjOx?7esMlr$~v^ngCAy&>03Pc`ylvZg!%PSR3tb;+xh1>j*DYQhL4KRZvBP>$ItX$owr_;CyLv}uq$K*_u^hjP;f5scK#j`WhsVTq%)R<=hQFRG zav^`Q{kZUPC&JWi{}F)A*TS~jPr!vm6V69qzyb{CPk>;Tdw^ZKRWP3fT&zgW*=bFu zB1=X*rfwkh9dk!JLo9Cy%zsKQi zL}LfnMWf%_5M6{ZfN7j!47yzVq9!W*puLNB1Gd;6jwPq%*`B{bYh2s&KAeH=q0b*n zRzfK`miz#~EFWIDfwA6P4>^)`OE5W^UPU)=;e zV1pzr=pQL(7MQsDq8y*5%>DyjGow!iS$D&X+yBBtq1lfFL7(Kr{x8GK3?bR~7+5K^ zVN(8#Wc`#hp*cuMKKY#el&DpLT6Yc+%?v>{rT}8uj~NIE-}qLk&!a-@E}U#|W|G~% z6EUODe0B-Vej*6^46{p!vfJNdSL~K@41(3?;HjL{qmu5q7DfxkgqTmk}o9`>^J1v2X

z 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 diff --git a/packages/Moq.4.2.1510.2205/lib/net35/Moq.xml b/packages/Moq.4.2.1510.2205/lib/net35/Moq.xml deleted file mode 100644 index 427f8e6e..00000000 --- a/packages/Moq.4.2.1510.2205/lib/net35/Moq.xml +++ /dev/null @@ -1,6088 +0,0 @@ - - - - Moq - - - -

- Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Defines the Callback verb and overloads. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Encapsulates a method that has five parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has five parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has six parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has six parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has seven parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has seven parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has eight parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has eight parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has nine parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has nine parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has ten parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has ten parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has eleven parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has eleven parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has twelve parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has twelve parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has thirteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has thirteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has fourteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has fourteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has fifteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has fifteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Encapsulates a method that has sixteen parameters and does not return a value. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the sixteenth parameter of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The sixteenth parameter of the method that this delegate encapsulates. - - - - Encapsulates a method that has sixteen parameters and returns a value of the type specified by the parameter. - - The type of the first parameter of the method that this delegate encapsulates. - The type of the second parameter of the method that this delegate encapsulates. - The type of the third parameter of the method that this delegate encapsulates. - The type of the fourth parameter of the method that this delegate encapsulates. - The type of the fifth parameter of the method that this delegate encapsulates. - The type of the sixth parameter of the method that this delegate encapsulates. - The type of the seventh parameter of the method that this delegate encapsulates. - The type of the eighth parameter of the method that this delegate encapsulates. - The type of the nineth parameter of the method that this delegate encapsulates. - The type of the tenth parameter of the method that this delegate encapsulates. - The type of the eleventh parameter of the method that this delegate encapsulates. - The type of the twelfth parameter of the method that this delegate encapsulates. - The type of the thirteenth parameter of the method that this delegate encapsulates. - The type of the fourteenth parameter of the method that this delegate encapsulates. - The type of the fifteenth parameter of the method that this delegate encapsulates. - The type of the sixteenth parameter of the method that this delegate encapsulates. - The type of the return value of the method that this delegate encapsulates. - The first parameter of the method that this delegate encapsulates. - The second parameter of the method that this delegate encapsulates. - The third parameter of the method that this delegate encapsulates. - The fourth parameter of the method that this delegate encapsulates. - The fifth parameter of the method that this delegate encapsulates. - The sixth parameter of the method that this delegate encapsulates. - The seventh parameter of the method that this delegate encapsulates. - The eighth parameter of the method that this delegate encapsulates. - The nineth parameter of the method that this delegate encapsulates. - The tenth parameter of the method that this delegate encapsulates. - The eleventh parameter of the method that this delegate encapsulates. - The twelfth parameter of the method that this delegate encapsulates. - The thirteenth parameter of the method that this delegate encapsulates. - The fourteenth parameter of the method that this delegate encapsulates. - The fifteenth parameter of the method that this delegate encapsulates. - The sixteenth parameter of the method that this delegate encapsulates. - The return value of the method that this delegate encapsulates. - - - - Provides additional methods on mocks. - - - Those methods are useful for Testeroids support. - - - - - Resets the calls previously made on the specified mock. - - The mock whose calls need to be reset. - - - - Resets mock state, including setups and any previously made calls. - - The mock that needs to be reset. - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Supports the serialization infrastructure. - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/Moq.4.2.1510.2205/lib/net40/Moq.dll b/packages/Moq.4.2.1510.2205/lib/net40/Moq.dll deleted file mode 100644 index f5b15459f8e71b4a8ce35376e8ec806ef383d560..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 664064 zcmdSCd0<^tx&OVh_sKpdJ4xHqq$i~XS_+NJ1Zu5_NeU&PsFWEI859AT6?V;OMH^0t z;D`l>D-I|slQRye=*1c50g3Yj>UF?*x?bmd%lr90YwdGR(gf;#??1ml_g?E+&wAFg zp7pF}J!{zO9CO;sq9lr<694YMKZ-uYTYuyBeBj44$%|Iqu_$_f*IoO3sN?9n_BrW- z3+t=5OyuWJoOSW)r=4}lCHdCXXP>)zV%sIFFT7;+V~%^m>WlMp&Ry5ro9!1!AAdv? z9o>;cKi=X_E=v1R6tC{?s6^3 zM|*^Nsjl$d{Rs>-Z_8#u z@f1g$(TC1XqC3BpMqL5nr-vueH&#W_IlQL>?15e<$F3uavN&l_i7YNPkYzR$MaRaI z0wnRI0Kyp_ngb(!7Z}L9z^M5yuuj4H)^|mR1m@y8HOLxhO)0KZ{j5>8V7G!aNGb5y z>H5&EIB|>hD!D2z*o`_UW$$R)HLhyjCoEf`BFfYQjSEjUCSMcigJ%SrYN@@JqA)V z(r%SIs*V8te&`R*Q$Rugz=I0N&zC(2udDWH(OM5J6vb#s8`|1K(Il_U zPpsf;^_qfK96cObG|ED>90Z4ZcCBN@bSt!9i=MA1c^0CV56sV6vrXpK6Hyy2sd`&I z6-{#5f4&CZwVsL96Ww2!7P>lbV0mQ z%E-d2)G4v0Svo2*RO89Wh1co4;xusw05md2r*C~vbR~Gmz8X&|yDVNhu<@AyOYIGN zW)slfu$yN?=Qivx$;q}2*kSlVFA>8B;bRPQ8V$6SSE|1!j?(RO>(&!p4kF4@t*@-A zPD$gV2{m*K`RSPSpp>IUX}UArll1x^(sOjp;St7|s9z#Zy*Nf`?8pc6Q{iAlGWTR4 z5Nd5~)w~4KNtNW;+C}DB^jI=MGU$Fb^LVOg3Z43Pg?u(ji&J5QnoYpZ7WYsAk#tjg zrOvIkX!Wh`=!syV_yv7Wb&kf4BG-aG0uA)(Z%z7G)@%Zm+Tv)4%zBS6Zk7%`%j97F z%sm~Byy_+SC4{MZv(KOCJCA#^gwMbl)rJO0ZlN8BWlX7{1JrvN@=xZ zB)akgi68I_8(zB1H|WagY}q|&eh{zP`Zwaxj6tLrvrmuKGzuGBjb05+WcV-geOf!; ztM$Wlyci_XCNidyWkt5E` zK{xGgw^j@TQ8`~tnwh*Yb$f5UMph6^N8vdt(avpz<+IQeLg6x}yB6NlUieJQ?85PJDBL>%X#DK4qZ}O$zo4LLtEtr7P6+2Hx^?nqCp7bei<^|(`tHzK zQtK>%_9KA~T@r7V*~p)R>C0z#)uEOxC`XbSzD~7HAE23&{9xX3n&a1J`6eFZ72Uq| z9v8b`tsfe2$35<0!lfbw?#b~$gMNz3|7am34YZ~NoegpQl}N+AiU-l?pg5jXQjSxr zyqZr?WQ2=TP0R@N5A{#cBTHW8vb2`ujFg$_U7BMjvw^E&T*{c-tU%d4&eQTduZ&&- zJ?hw`m*j{gGb$5w;Vte+qN?|1-bsEGPlv~lb)yhXOrL5)lY1S^7Hy2Q#^yd4ADwsGoVMy7r&(d|io9IyO%9;*h&Wz7OalBhX) z!0@QFD9M$3DKWGImt>+!9ST zeVy|OXTdzx&Vr&u)Kx9bl2Nz$4~)gtnS^@TAh_Jj54sS0H5f>OI-CRnjKvdqjqZa$ zN}c6JodZ{+&>hrtQR!xdDq8Ny+>>|=b)r{Nn%=Hj6SJ>WEfu&hBjg*qf>QZ*>$Ev9 z))0GcT0r+?P;{@SZL<*#%TtRf+_PzlX;yNeGc#@KNaY-pq8Zh?r_sWd(o7wOmCmJ$KIS!R2b7uiSyH; zBL7c)kdemzD1o{S*PlX~JA+3Kr`fb>N75oCoi#g2ebtwo zzHhzvaaKw9-BDPmEOlR{E@^%)^tzL>`#P~WDVOT!0q9Bc^LcHB=MK}p*v*jM+f}LM zSCCtiJl{4wHa}k7q-*rDBz4~~dTIRv(Jy!A&&EwFFF?0KV}25Rv(@rp<&U9If!Db- zOZ5wl=%UhtQ0??oJ+C*$^&xm@V0(+Dk@`i@asMt(>rYqkHZfuH>W?1R5k+g@p+Adv zEQzC)+m`a^E}ID|=g$CrC?wFH==&%}G^*qmlVGU5U545<3l#$wOW{ZF1(_j8gGFEG z;%H}0MdX)|c>;^LrIzOe`_gKfZy`{-NgCZ(u6E`hg2fpjTi5h+84@Fs=o`aB6KKp9 zua13{YNb{!TQ8_qLSFB>X-#N29aBd_vHFSBw^9yT!2mey7$1k-rQ)E=J)4*NGJGz- z8r|yX%c@zejR8nxH&(NOY8OxU9AfqDJhrbR;Dd*X#Hh*1ALTVc(@}ed|l|>mzIge%1Q` zWsHX~unFTaTtZ2k+iy59BX_NYl9XCuz+_)A|m;|Dug8 zMURFyQ`l<#Y7tF48`tno`x`Iyub1(nsyow{6R6YBnO1~`yVFS_l+#He1hXB+f=YA> zG!cC@c1I$vEU{O2YTi+Y{=~~|aTJ{v-%L*P4a=>ddnK8|I#3@z z_=~|Drkwt)K7 zF86k<#+Wz@xo`_oZy3q6zcQiVGK?e)_m#?%DyUkjlqXeGXP3K^4AeQupes6uFg2^L zy!se`cuk98=u&jI(>)Qk7InI}QRK}^Ob6U+AnwD<6Za`d`N$q^2`ftOGtC6|S~7Gm zFV}B_)^@KaX>=N89w50-QMsnG!Wfg*uLFNtP)l-n0N%W3=`|OQt|p(AG*Op#B4+H7 zn(>!+nGH=);+AHA>Ws$7vrc7=$?Q(R+LobsVB8{19*$?Sn`S1Q&#i zpx&rgsqrSgcBVJ*s^7@N?L&#JcJ=umuKYKXs{FSoN78t+UZuuc^xB!el~?_3JRH8m zF8Mbo|JzAb{&y%x(s-v{rN*s#?M&artNv~t^X7kq^1p{v<$teoB#qnjDm56~l>hy_ z>L1|Y_MNBv1C{@FQkDOM%8@iaq*tl&?|SV_@8DHue3)B*?>{m!&G8=x@{fSr=0Mgz zN_+u7Zx{b@<@%B6b20N$@pUoXg6*^XV-Uzc&LhopK;30qi*=s>;(m|Td#z%EF@>$n zZmhI99p(Ie^jKTe=L0(lr+joO;voXlG9E%QU7m zN#v`6R6A|L+Lwj|EpzmhyF7(TwS3KmW`p~>%J~NEAWo*M4!4r@lA#(ZeWz`8f6kiukTI zL|1F^&?dRXH4ttReap9t?3PxS&X(QM2a{c2wXZ3=J}1{k%`Itl7_iVL$SRQ6CJ*59AT|BH>}oK z&SlCLH@?G|Loa1In$|x@Zg)A2QLF=&G@eHz;Kvh_vWrK8K^M1$1g{{rDseDEE4$B= z*s^bBn}d!jZ{qg0(q>cs&T7zA+u}Q{*r{Ok57{e$vq5uO}LZ5X}wUFN-dwEYSVQZqoGz zAj~m4BW!VmB(P`aL11jKNv~yN#HS6~fwMXtH)C5PjP;(zA@kAr2P9jg-viJ{jgL*D z;nz`GeEe>AY4k=X!2F?-jjxNEz{`AAU1l~mr;R9NHgPR-_L2{azh415x2m)JnsM>j z@9qZA_J7=c@K~RbRAN&D^Sl!6f2VFOnv&JJZEq$m-&96yJr%D2tpCLBR*-J&8Yr>a za|UDv%LAu$m+?wAd@Zz5+0GXn_P;4pCZ}0uX%7AS0{tv{K4|)jC&^G6g<~|H0WqC9 zxGAbN)XtA0cQz~AO4cwNl0U8F?Iw$PX)K$M`d7h^>tEwp==wpiV`OH16itu=!Cdwd zCGYK6A_O#FNTeGp8lL%B39|KoD?HC!_iirkUdoK{=|E~k@aOp*<{w?aqaTBqa z=HDj5eDFtzB7YkX!ar6RS1T>%gl~waXws&$`CF3e-yz?$pq7;X2G|gIv~3gbcTGG& zEy?3)4o(lye5zXCWR^2&+#@?})_g`m_gxBTp8_L)rofgoOtAhv(z|^v^6wMw8BrCN z#_k>>y&khGzn93pQX}ReEFOKBCeD8VY>))Q{vnYAzTj6A;+?f4P+~tYm2F2N{}Ji6 zO;Ypa-ah;t65dYrbyhoT}uPK?Bgd|_FqHG6YLsaZ4lIp zm3+b7|G?ndu?k>R+@XsZyJkvBq+Ii+7kGZ|*JbOk|7rE0l$+elpe6@%^ZZ^?zlBf2gRRWI2EbSr>TgBqF)?x#vG}Leu z!h{n;5TK_TG##2+J70dfTo@m}(rioZ8+cw+&W&Z?4elbmeRu2sc#!9ht@tyT zFfgBNP4Cu>!!&~VFLKq|q&Ztx{w$hQ+umLmdZSy(h!pXWL@7)6+^DLitFn!k*n437 zYTmJ}>vxyk+0?#l%~np_PHU{KhuAP}l9=ll-Q5%x<9Ed?epj2EDz<-DNkY4CJpoc$ z^0JyF;cfb94y7so5WC@^Ve|XeuZ-Y9XGh^*S~i&Y4Txh1+b$b3Li$uTn3`*8M;uZ= z0nPsce6&lIV=uw3 z@Ziidif%LUN3ySS?r-4v%_h~Z*5$k07NCv^`mmp>l?FVsA!Zvwvawxl1(e+1$<*Fs z{y`jp6z$o7=_8x+z$i#8-80n1cVy26Q(=EFpfcbW`ztopnJCA_PJs5?jFGPVpHS#4 zdEr#UcAVM%lAnKd+SXgYja}})Jv)J)BzhtI&|j;26l+@(1C$ZgvL^OzhL=w~tQnqG z7v9q{(8nf@DH6&96Rd~%%;n`1Picntm^i-~UNLcHGrV%*<<0Q4`n8|;wD#8fH9$p2 z!Czt~wPZWmoI|j^T_3AqU!@Qwdyap-Lp{xRmLnK{B3ZKbf1M%z;_#L|M6Y$q(*CvM z7U6G__ImymalH|H^eq1UVh+5ZqxZY{cW3xllv~iib{oC9aK+WfN4lsmZQ~`C!p2~2=u&zzG1B>`S~jwZK#9{Bm=G4)?Ui%HISVJG z(t%TOG%U}C?+gT+z9d3y_Lt-wx`C#iwq`wg7;yI6e+{{kAM#@u9F@@n{2K%7=?vWG z!Gyuq)4*08t54thMYe9Q!pNQ&o}NB?pjtApp0lXZ_)yieNmVl19OpDROzWwZ#sF!* z_#hR+Uy@gVmF(&3w6{TN4xoDCx{3QbEt|Om(Z{CzCGSTW72~(Zvgqj<^Mra0s^`3f z3R}o1V1JxsGpXt6%#nE{aHMg*f%R;sj#9#=o=}(4)=`?wk;k(clGLXI-Q;l77cWcf%J6LMZLnyGBb+-B?{8m zTJpzDtoWdT#~E19S-LW(J+Uxk*0Wts%MGe0a-vz&I*as~Ll2sA;)u-(!_sqCX-1^4 zv~)dprGkF;N}l%Ty|$9~SY8Rob}E;K&~RR|XS+TyJOI@by7Q=Q(1&*Y$83>BPp@xY z9riQ^^_-tjA?sE@+RJk2=~(Z~f?BOIsGbYc+3ZLDHYR)@l}_j{$yXZ{Jw1=19rrP? zo^#r`U>uvv2`4+jA&dH-qMSH-|aqB$WNSgax2K5l>S6 z(hLh7{wzeYLqQ!JmkR|SWjou364USYgiV$Slq1d8f->3*P5~HHo-}_5udy=l)DcXF zQb+Z~q;Jb*(YL8B&H`fx37KEZZ7%cGicPMEidsB_C2F4|iLPJNAnk(LX+6y}H==G5 z&s;bgVF?IrlP*f2hx=I`V;Oswzo&jP+3ZZ3ug#;l1L*@jVH|zRtGE9d1W9wLc9}9I6_oHvUkRpq8X_ zsNqnR4#CvAJT-p;u|KR>l-VC(y+T~y$mYcUZQQSKagW_;=e{%n>A=is$laRB}&tkoa3q4z6XCCnit24BoFU(6@3&_TKY9h8A%t$nJO|UnxB|iY3 zdjjAy0;~hj8+%Rc76+z@{)CHZV;@`3Z7Vj_5=%B#^}()kfBrDCZwz?+ z_Tf{Hs5pB_gO>C=Ojdg;?lY%;!01gyhv-uSD3LQx|o0M@OKf1iRgwoaMAcM|McF@zZZso zb7|9cnt1JWg(p{Y9)bAwtLRaE}U+gB2MK5%b2! zLPXxU+ZZB8C~|m+nD71Q5HYX&u_0pq_TxjuJnhGX$QdGVgd!7vq%C|S>^NM|4Kz!g zI)t-ced{YGe)@m#d)gct$-?UY5MTc@Mc|N7hB+~tLd4vcL#@C^Bq~s@(T=lc7wGMC zmwihI!9rWuQ4ZRIJJ3ZwcQAy4Dsfz_P^Dns_l+(@=a??R@9}7Smaf|S5R@`XS8SZp zYgKkCORA9-gHi+7^HlTEo<#)nV>7&=bk&-TFR@g&@iu$!zwv{-heE;6DGH7!)ic5h z9qpZ&W=}MVbe05d>BPDRiqVP$O6)}!RS1xmHzDolMakFBn;NpVik($dk+;e9EUrS{ z*R=>+KlOF;^>fD}bKhroEeWyswp$(H7eyyGWxsM9&p}@OuW5)j`!I1!tEjL>+An>?m9EBUreZ!#Ug!A*zCAW}i=HX#svHsiHsPjZ{)hOo_TL$ys#cP2RoG8^qvzMz=` zgdrqU`vXO_2PNM=_H%IE?9Z=h+d?D79#=HdNK0mZ29>WSX(4sLmQ}-c{SR4sB{M&i zg+B1O=(AWC3_j=DlF^S6u66rq4CiS!gFf?gnLVZ-nFfK(jw23$aukqSj`e3Ze$=$J zVqK<<&%)M-jB%Sc4bGq^?#|>WfnTri+Ayo9sfe<^xEf}bA`#aaUow5iH5{ZktM928 zca{iZzYFzRfS~6;$24cW%yz$A@{iEkIgCcaN7aLSmM`Gbf^{3uCWUKj@v zm#NOUvHpa%r|`pqf~@m{w^h4&@r^y7oIL4SR`OpW?QPYGak7ib_Rx*r?{3C++jYx5tDJ+9 z^`yRkdpSInV~e5iilcX?16kRBjQCai7_saxD)76i;huu7hy$*4XFuoMk2ju`m4&B8 zSydn$rOk1*GI>d}Ap1i!1FEJR*iioct@617 zK#9_ckT}=hTe-e!-#X#za^@*tvLG!f4NGcS{x}|m=HMJZkmjhBA4qfN;|cl3tju9C zgDwr&ZUF9g%O73s9Z(Is7|NzgSuQoTmZc6@+oi|tT3~?8ZL=_#<2Nlhpv|)54^&#) zkl<}W(HEITSpQ&h*_0?IZb6BbD*4eQKafOs>5H-hT2wZlAA_U$D*avGepUH?{fPaM zpQd5@*Udlm(ni}qb-(tw!h7*=U;eRzWs?BeuL4JUc^Lm5*9KD>PL@p}HH|EA=X+zH z?7Osc1K!ia`FMIA|&xhFa0DC^%o{zHUMtdG=&m-)qp=M~} zC<~up&nMdRRC_+vo=>x}a z*eq;2(_YJu5vF`Q-R*K7xM!(d>`eL8CoxDvtInx2bI3SBW(S-&5+li1^5X&amd(vc z?fjEB*J+o34|G?&z5b@z>x$XyinrIr@)|^9!!mbj;Oa||3!AO0&b+=WKM_2~RD3v$Cw^T` zK1QWA;ty8*a$NJ1gU9P=XZuKxpu)_eGNJbL)GD*uL8JaFW$KXq|BGSmYq9bhJxw}L ze*%JQ9LT^CU&fkEY3H&FSl5l~Ckae1Yo26tSEik25jpkcqDMtP@ za%Ogk4PWz}L!>)d+TqS6!0S9-`3q=l(#|J*!1tS9`sK~Dd7+$`+jkze(Vwl;n({{} z2fIi)YSK}ynE7D-F4Q9IM~4d>OxNodsPvk*lWD~?-qd_-5qZN64VCM17P+#@z$rZy zowfb8*S7p3faUz@JjbcEL&4z$v|5ZNxU* z-F7$08KDvyXG104O(j@EcG1oBdpuCa3D;0#OtL~#3NE>V{&I)>63UAwHz=)aR21AE zuXQgZ)4(b2MV6NVxitDHrF;0MVZwX3n`we7K4_7X2SGdBk8+*L zoMacF+G1@ZkJAShJyck~)@bF~$y9{Z1p4s*Rc2LYQwj#%&TjE5Gvi9Vn** z*INhCXdRh_-Y$4v>T~gAcNkw9lD)>7&33MGc*iqQ<^rhk=ikIN>GHW&!xpx(T0h$Q zb<$uu#|ev_=`rf9b!630GY9`Zv%7NG!Kl`c4fyv7-%UZ%Y&u^c3ex(Hr^f@z?jrRI zDMz{Dn9p)Q($4g_*@cj(I%xm+YQh&$j{jV(!N}VDIKigj@f01QxefA0=+(Ev?6jbk zRZ20bRTg2 z`R?z9?! zs_j<6qx$ja06=P}u=!yVn>!1SESQxOQ9}ROYq@Re?pH`9M+YUTOqO3p*!oxTEy0F3 z|Fjas5Ez`Vo*iFTe<#(LR$~m&pG)rX2ouEr7sKdEsdG_@?{1%k_;hZfGunqbKSOOx zH(^Pw)VQ3teeI02vpP;eCSjXwg3X&PgCo5>=F-OBK~mlqvH<1Gk(t^ola8^l?>0kb zkjMk!9JL!bIIj;%=a}8VId(U2SOtI3vM?bJigUtl;GDP{I8WFOoRf9~=ZU+4bMkKB zJZU#@PT36{)&oq2zl*0B%(CLJ#H$F`U(I7$P)lmys-e9>%Wp@^2$Y z1xvbqonbRJzK(#`_16=U9e5yJM@O5wt1~__`%HKFp4#XpjW>ucWEm`j{f-X+M&^?oTS@uY-h%MRhXHEa&Pq1w83H65(O{GCz8 z<%m0nJ$Q-0^6m2HG5n5bv$CZq}?H`4mMvqS?mF{qpLNLysOgQKX*|TW8M*H;9Di`!#={87A6TEp#9?;p|_3t_^hR|jCgVGZAl!*?jz)N zALW7b{}wf3GIO1(xHnad>zA2;1THl`CM5rTWD~<~Go1Q3DMd&B1mXH8c}xpxN$xE8 z&+jA}vR_{mkbhOBxKEK3_(%<`GpHxh|h$8Llh-&9RB?OjFys`z| zqa2_sY;7+@?2-?)q1GQ_POPtbTCq-VjXlGWFjavR$c_f=K8fw|8~ zW49CC-j;kOK%dO!b4WHl=9{})X|h|?O5z3I=1Y`d>rECgnESF|htDA>{LS={yGU&R zPJPT@!Za99enr{%_HXiT0y|WOE&Xzr5Aimr&Ve@dM80UhW5O+^ws71QPTIoQjwVj0 z4{L0x!q=tJ<3twi4V0R?vwd=y7gnOfzuD+ZB1~EW75_3d{rKy(-RsOj))79OpkF zs2_A-*!w9#7I^h>guXwOO`Vi3=C?y|^h}~tKLe$u?(t>nCHad`ip-M2Sn2Iwejkax z*XJ(;r8{orEc*`Teh!Lt;D)-{P&~H)8+zv_*Om=|pvUX#S5wNgSoCwk3#_?VpJ0CI z6_;h3;h|={(^*{O(?uRt`X5l4S))TmyySe`>wGKR8Q|(Czf!>nN%tkbmG@=pqffUr zqPX#2tO$kiRl!}pw`Q`(cxp-b!Xdcr2x`XlGJ{a_pF{r%6X?e^eN$)nbMBWxgR*T* zUD)Lr-H&`-{_s_1yY*dmLeJ0p_0j&YU9!<#4t_x@p0x*9tv@61&F*W#w}QLyog1^3 zw51trU6}>*!%gOYJ)3#Uq#LJZ*C6mx*16qi%Jk3b#8yBD2g6nXP3?P-ZI3bO^t)dp z_)!dPRQ6Xpx!<%G6fVeUzlDc<=!@3=ZP8Y67usG2EXnJDg4 z!ClJo?Pf{79t!$;95<^Topxv16{5W*(EfXiwt~CR_VutNUk?TCMm6fuWA)gKmgc`v zhwigg)#3oPiAMTOx&Qf^DXLh6 z{mlD|rb+TYfTdgIY<94;W9KrZm4~=({1%0Z^83~gMR@kn3ru&eKpmVN+S}i_Q9NHQ zu4(+@iW&nd-gZw7->F#Mv&k?@mx!A8?fHZj5p$|poM*ixe5$-WptMMOoIUJVpAWBy z?M8FQ^l;emadNnr&%5R!KT4HZZ6{uXOFwcfT-eTjxR%A(J`|};;X5{!?c%1g32I4m zj`Z17z^-!X-s|dPXf+0-c`H?Et5l`EQdWgZm|Rp=OgxA48y>bY@TP0brtn;wY+WL@ z{s^7Gz)j$*dHWWS^GLba(m@^*rED7GWU3@dWH?Kp92Pk&EM zJnIaDes4hY@fV3klK-c)>0X?%sC$a(Ef;b935b8@|3xtWb2Husbx)-pKE9nhUa=+m z>+Ow3w5)};0=>x)fqX_jzr zc*}eEBFM$8xHj*_QQn^P*cqX#M8{w0+3)vm4un(hhx`YWn!8aCa8*{g(khHop6*LL z-H*WFE_8qPzo7f8*kAmA0Nlm-UlEe+_{2^#$1yE2#rb{|7QEcQf#AJdeoX>j`0vE+ z$5Z0`AIh6qhQE-Z=?i!2&d_Lw$@R;kWQHl+c3S)r4ef-bIFB+J(~9rAwT7d-S6kjM zwdGay^&1K+1)Ddo^zAp~y@tH?f5Mv9e^`1d)@c-+xn1UsQEt{c4J#pdkV8M5aGk^7~{fq4=}DRWPU zhPiy&N_+;9rYIMI$?e{42(7lL=SYz;{-w|2fnvUwrGSao3jH^SMy719R#vwL}=ACM3I ze);mKGD)-;yYL%i%7-RqG|RJYKXI)H?U%D!m`%&jNT1G5>X$Nt#_riX>->-y!L2-% z#`ke&w%JYg8iS7{s3mzHiM0+Y$}b3*voi$E9Un%U>}Sv*tZXMxrlz0KE0`CtE`gu$ zBS}Hl(tQeyfJYTPp7eb)iTX=+d<=57Nw~P9WRaaUfpXlZtaj)g;4JRw+$F&dF9gD@ zVa~eGu0{Lf?X(ryS<}g7JSv}`1yo(#b7L7)e`!xUD#G%sGbjH+8QJ&h0b+EHZwskNI07EBOsA-O+&j;164W1U%lH7BZ z9lUee@Ltfw6V#GCp86z0(kF?W{}DHN0$<$Bs1cdfsbM)K}p(_k_cL-}+_I z4dlC)e2Kp%PW#aqrBiU1^VO=XoVkh5p!D26d@_mN(I}Z-PJ9V?+3v>aPV4-N2-W7% zQ?Asv^X}!ND(Kj6WqG!`@)CU6ws`CsP%FTlfc4RJ0pNNGARdSF`o5cnw()m)y$YVW z%j-pyBTJl?m>EmnzW*<>bF{Apr@jxFp~S^7XjZT;Y(SL{CWjs_L{F2mC-mE|N z@v8S5O{Uy!{4{^CB`lB#f9A_{=GMSwSO555a@mDtuU8ejFYUD|mpkgMT(17n*2Z$Z zN{v1A+L^B4RbR=Ye`b0X7kk(>xw?PUU4a_TDEG`)=HX%>Ac*d~2+IS4N}LyAe$f~8 zko>MwJ@z8M%yVaPK39IipP8A5^9L{Ybt-oa`Bm<|yeW4-UiGy+ z`ezW#1GJm)XTJ8oD);p&_aWq0xsEsGK9pB|h)4en4$cFVEBu*n{IANrUghpjewBLw zZ^~WAtNt(^{WH&dz;cB@^R0ie+;YUEC3=I(y*5~qC9)*xq+a!hL$k41fSu{9NUv`& zMqVa6*zCY_8(cYCGyGlq3Nzth$8>hMxwb~Vqc@6&R|g)Js>r0#r&l^@u}MYhj}Svu zfp?~_X)*NjSqv?o(|44AE<;7P5!JbA?TXoA79Q0n-X8Dx4nj7kdqyF1i}aHuiueyc z8H+M~Tng@Yo45)!aTRI9wKeWEnx>35Ne-_yIV6pKxbu6Mp%V+xVmBC{7b44a(vn`J zptl(FqB0u`s56WU;d;YMkzO1Kyo#{33*+{=45T)0TL9ixGS05%eFHqkj!oIru4vdQ zQr@fNwg$~R+vbwBT2#?oa^?DcBIcpdjpR-IA!G0Gt==f_(_dj{_k?(tZ|mt~svpO^ zdnnF=Z=MEs#b>TZx*Dh+Lh)v3)02#Y3}gA_!Fssao(5tn+WISznb|9^no41MGY9Q5N$n(mAGfCaqPoVHDs#8pVdf9szZPDGigY(FN4srRw7!yBg+=bxR)Afq z9^c4)>J0grUkzY6tpo2SW;K801Ad({jz&5Ty|hCMY3yrgmy%t>#(7dX_Co!2YQ{u> z{WzXfVq#ZrjmG3+vSpxcIH(&3jLTljggeGh$;^w#ohRh}%dS9j`I z1Q;&c)9oOrJnHLwi|O6~l?K?{nb}}0wE0fo`u!qy7NeV?SHI5NEL#k0ETexiorD8c z$=MQ7+^;uMeSa%GzXj5Q-U)PyeV?W;d;`VRABmNl7Sxj5)v#p0K;*6=)TlwTpXqap z3SA`|rISYW*TGD07r*NRPFFjM*3}xz#a&yz)#S4u?dsZ@zFyY!Q~-{d?J$7r1vm&! z+{;uxbIIYJk^L!TE`|0u{WD7^#i8AtsGozxDbGf4BcIJfCccf!yy9xQynQ}0OGIe8 zU+}O={75HxCiX2yTbPm$%q;}ia$B48rA=MbCc_&gL&mjiT2M=xvt&r_J=!UnAZT?i z#tF0kM^W+Zt>5kH(t1mDi|LQFz*?L65Ht8}>gjD|-=wlf)P90ml4BY-+}+$KOKz-` z9WyI`t8;H^i_T#q>G6JJaPwWc|3{bxoK|tNwe3TMmn~;_Ot?$f3r` zn=RsmZ%X1x0sK7y7R*_8(N0kmoe@t8%g%%NpzYcqlgzGbp%@Gizu3#fKTUS9Z{pW* zbJln=_g;X0z2=NqhY{Te0O(d58NzKUeG|Vw-yUa7HaJz*dpWxf){g5a=WWQz&-C$m z(><(**@es8@|Eg019m(KW^PQE7fS^2FFC(i`_Tu(Pn=9Vg3dN0F3nHL4*`0MqMjS} zKZUyqs7Li&_-Y*rbm-)mU*-9C)#5fD)PnUs$xyns4?MoT$>ZNiZ?;(M?l2y0zyRI& zx-B*Q(rZb}|rQJh8QN|BF3ek=nND zuV2r52fR(ORKOvU!zp2OH8ds;Gl3vCFOWx*P=5@MES(mr;X_|?TrtIPM`ibpr!8=@ zHTpyy3YL-|K|XK;{Iv_fKeGV*mkYr6s?1OS2@AkqvH<*j3&8JQ0RHC%-~(Or^K-}o z@W}<>Z(9KV^#$O+UjW{l&Ck!H7Jxr-0r<8B;5RJ*|Ly|t&hGj7!G_GMC(l^`{_hLG zf4%^`+A}|W?ApBL9=QN~+XCZ19} zedq%4Ll=NQWdZo*3&5{m0RE)~;K}0o`Fzv@@N*Y{zj^`qrxt*hm&{-8p$ovTTmb%- z1>k>N0KTj`r(E5s`bBK>JF(aOGxIIoG3w3yM={x+;Nx`v%Rb%xGiAos*1CmXCSbF; z-1e*1pJi~cC5y_y(q!i{(dpWuXN#nJES7vu77h(Pj-26VrEDX~|Eg3;*QyV@$B_lU zL^y3LhC20XM;pQzqIGPI<+obhc4wIsUkkTTzmZhtEpgkT4Wt9@N(5cqx?Qb5-p0VVaU^fnX*TOsY8=Ju!PYUA zW9FwSoK-ZxP3Q|N7Gy+gUW8&DQ>Dy{Fju<#)Y2^3l_lW;D`8iu-KTV}(9(XxR zIISg@HpzsBd_L{lDk{jTY-iWrtFmqgWv$iZD`^Z`kq^9JCDge^7V=U4xoPb+Z)eBr zgg;lt42*9|k)75SIUH8(+bTHo^H~iND#i{2YehvD9M|Y}@$giz#lxAr0}l$${MW)fC_V6C!N7yU z1rKLg_?$K#*jN}AQ#2wjbaUNBcJP_-@ zR)du7mqxSZ>G8tel_J)Qw2xD*pGQW?<9yzM2L)&Tx-bt)4?I|KmM*P;@UFT92j@x( z>7;Uau2CjM3T0|>UFkG6BF{N(dQ{SPC;FD7TEBp7;`u_}foBD0n0mDt-!>zbPAWa{ zY{Afm3KwFVUylmTDckE($*y_5LwsCBZt=kxh=LCVXa2b`A4(5=STOLRaKXm|=n~AZ zQYd9Ac-a77ABLBi->6JBg|mrA@ zKd+POPwrgHSwnwb(ze%&AJxMHYCCUHj>akP6O_SMEj7Fu`^?)@o`G`nAVf<7MqP^^ zvnhJL=rMYqG@iGL(E}mx$$hn*T-;(*qyo*hLqcJ_%Kxt5oks7=a6Wnj^x}LQq{G3g zRsk6E7QYW(0E9fxzKl;<8DDCZf!X-KD&xA?E`Og{Op(@A94j~Bi>S}Qb#aESZ+$H~ zi;?%!;>DlbIsrE`tmg4EujXlTq0l2iip$sSf>OTDZoBWPjP+B!vbHW5BVC8yx%2+}o98;@U#ZW1Ml!cWRnCf*mCbv) zu}PH8FkFkM%vrQ6ARg=>XK9{I6^pa#&mmmj&SP3oOLA<(4zqq-{C=XFB!xA|0mlc4 zT9a%j&N`dkIlis&Rm7PWSe!eRl%C``+5)Vb*;yFfX5Kf?#l>k8Zb6GR-`TWS+-y&O z``mOE@05O8;EnlHx=qF2qKAGD&-1)g6+|>ToBCwlpGA)KDY(`6bUAOorX5C00cPT4 zp3##1a=cZgJGQNd`JhvRcGIHZ;f?1K4tAjueT}j{r?Rd9s7W83J>F#0$jl-FR@n77;w?+Dy`-?_%bPVkdt7xkgVI!;BB23w( zbu*E8*1(GXOg>*J+H0@?b=ODi#NC@HMDj;RB%h@ILQg|!H-t3(4#hAypO=msTK%sy zXOhzskzL#DnZ4#0lRv-8hw$SlYX>AAm)kZ`TgoDNv%Yr3+r3QG0tG5q$ffuu{0r1YUr=@-CF!Ynm7KI- zY;v-dW9el_RHKY9s_yldL)77d4i74C)|OZMnW`rv0B67J|27M;$0MqYGu$(D+`k)C z_jE#x&3dYjW0b9}UMbGSg9Sj;evay?zt|lie1825tT=p-a~Pmd2kwlVdX)-)wWuhs zKX1k8$DU0u6q0R=VP{PCs5UgCuxSZDaU!40|AdHrh?4s2{#0`6f1TqZh9QsMXKS_>ad9?Z`AU&shY(5{1C(65^j z`?RWN^jq`X7gEp?( zK;+18{yNIp=tabMxog(I&iwLQO509{dVBFI`y|Ne zFP;=%c7-25BcZU}d^+_KLdBr)1bD7rPhr!7T9Ug3NjMDla6{}4@tu;G@)5~?4VP!o zCK8FYKh`F?o4WRA9Q3}GwGY14X*_~O3ooC_q{5@>Uq0wh!8}Cn+)A=U zLhtXcoVup1xbvIE32I5RiW7;T;}2esm$nhUph;NJDLrNp-mQ8FiF)WYPd#4NR@{Zn z;sl-2W7py&Grp&~6LM3WCuqw2B4vK0^iEJqvO^D&vvm0Jy!GcfnK+Ps?eEinxB*f7 z%)UyU-*xRVBo)dTVEdq0d~6QH^wGeI{038)0;Vqq=E5FJp>tu!&jUMq9@y44*!FOD z6o(Wtzp0$xL~!|2!}lEvrfavCP3Plx=>sRC?_QGnK1Nt+(ddj>n<(et;EI~!R9kh>q>N`%qwoLY zzF``D9r1WldCa}#X3Bh(bn8msGl!C9qvs=wLYJre^UBC6t z(UOPKo3}EZ;lNr*e!Ipy_+b9y3x2BrZ{yLDLKoi~3s81|#l z-u`t*8ppp*n*Tw;_U{DjH)yG7{vPt|*pp@}?O4gPKYuR(hOJ;jYti%ZM!o?JT`CFn zxbZ&TxXJI=%X_YZ%&a1JYu{kjGPTnEGPTE7*7@;~IG(Z69daL@*;_>Ay4t-UKEKP$kt9m#}REN+hd3EC#EnEfhU%< z{aE8q&Q)wS9#~T)O*1P?6R(+TjIiK!E^OznJn8mU>}8xY!{aEJ)>F9a`Bt8{sHS}! z026xP=AB4@yIF1rGT60sFA!)JYZvUs`!)7(u1H@Z>-|Bn@R>VxUw`yX+RN>r%;{Ir zU-VH$HvMWsj-rO$yYzUs9`DiPy?WfnqyCCT^u4r>f05>|CY;VN9S+AUUZ?o_FbA&YgKO?5ua)Yb#9Z90SekzVN<-~vivl7mZ*7R> z{A(cg+^YqKUiT#g)>XfQifr#Ixz7`;mVDICfe8t1Uw3BI%jky2623TEdDb$^lOo{ zta~5K*?MHEr56m8w>^uaJHY=g`1MZ$&bY<8aVLSc+%)&hP|?39eu~&_&9|q2-mPF7 zqcUe-*NW{b_TEH&W?1wX5&Y)my!dnXf-A*d@cY#dKEQ)-uY6TPUApY9{O?)abr!5y z`9+b1qN4V(g z$FhQfzGwLtc(^a}h^?P*hVDI*FI~gz@|SrtFx|zg@fD%1wJ;Zd2^3GNR8HpK&CBln z%2}5MEH3m(f3YS%#w}|qKgS732f5dzh<^0-N&a;JfgyO2FNnE_?vAX2baOA<9iBl{B!L>&P#6?9S){q_2>_{vC?- zi9YR{Se^Ro>7`bW&raP;xkcxFhdQq^ObcpBfg;R@T#`}A<|IE7k9P+iAJgJd!3B6! zQf(HGGX;;F)3uD>ZkD7zc>5Hy!zO?4Z1N|lCDjHT4A0{2x5)25;ElTgzY2BygT@h* z%awpwolq)ZB{8di|~)tHs2tR^yhI@A?S~S^VT<= zRMPCW`DRh3PxMds{kdh{K7|L`Y$I;b4LT&KCDm%~p0-T4PvN;Y@!!?N7u1pl2Hd@E z_*#n^p-w-cPRX`y7<>CZHMvDW`o22S(#T%p3Qg}UvMG(fbLH&#GNC$zmc^GT z(Sm2mMxD5r&v!*{XHCzXN}BCDV;;DsQL>4TCEris$u@Mj9TI{ouZ97ge&L9)zLZ_= zxeLETyNBm2#8z~MKyfHl?Z^7Uo1l~A2uuucC*aPK3Z$&Z#F;egYS4!p!^3st{!8^L6icdwfu*AnSEfcWk^2) zA|6^koA=!^=8O7Qz&CrJE><5u)XmVgN}I$9^z$&4%ud^K z2%kBeh$9+LgfqMo2MYfq;0M@6ap&>wyI|Q8XR@eN%7;sQfU0k=E{Z3WG5l_^f=SM# z*}e$Tn$Q)n{0s3Cez2rWJn^5Hhie;{@I^D@h4;X37$X?}OY~DeM&S8Rc<4j_pYpcP zdRUy6g5^I0aEmeyO^m~_Uk7SYvSlH6A4q<)%*$s(JhfTf|6Agbl4%#5Xx}atFj(P} zPvTqqGz)nA_Y^P-wBeuK*?GKOGtzH2zjhvPr=d^K6im9Ib~fExOZ=CTNxmOq%(rH; zP&Vo8A4>CY5p^F$`tD;ql-IXwPjmud{c+;@a0w$OJTR27n4sU*ILqR-p(Ni|RIh>z zAF>xgyCgkeFgO1bym0DWFW;|x86|%0A&Pz_-nfg$a1MdKj{2vf|}y0m>disrz%df#^!U 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

H0Q$l-jblRh2$=IMI-%q}ZMf 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�wd1vRg4RyZ+6h`aQEMk^?L=Lt6YV;c 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 R(6L!xKWqPY^uHg0e*lyF{NVrq diff --git a/packages/Moq.4.2.1510.2205/lib/net40/Moq.xml b/packages/Moq.4.2.1510.2205/lib/net40/Moq.xml deleted file mode 100644 index 7fb76162..00000000 --- a/packages/Moq.4.2.1510.2205/lib/net40/Moq.xml +++ /dev/null @@ -1,5455 +0,0 @@ - - - - Moq - - - -

- Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Defines the Callback verb and overloads. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Defines async extension methods on IReturns. - - - - - Allows to specify the return value of an asynchronous method. - - - - - Allows to specify the exception thrown by an asynchronous method. - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Provides additional methods on mocks. - - - Those methods are useful for Testeroids support. - - - - - Resets the calls previously made on the specified mock. - - The mock whose calls need to be reset. - - - - Resets mock state, including setups and any previously made calls. - - The mock that needs to be reset. - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Supports the serialization infrastructure. - - Serialization information. - Streaming context. - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Supports the serialization infrastructure. - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/Moq.4.2.1510.2205/lib/sl5/Moq.Silverlight.dll b/packages/Moq.4.2.1510.2205/lib/sl5/Moq.Silverlight.dll deleted file mode 100644 index 4c3eaf21e9272cb6b01467129869cf9da59a2eda..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 153088 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 diff --git a/packages/Moq.4.2.1510.2205/lib/sl5/Moq.Silverlight.xml b/packages/Moq.4.2.1510.2205/lib/sl5/Moq.Silverlight.xml deleted file mode 100644 index 84fad8a2..00000000 --- a/packages/Moq.4.2.1510.2205/lib/sl5/Moq.Silverlight.xml +++ /dev/null @@ -1,5416 +0,0 @@ - - - - Moq.Silverlight - - - - - Provides a mock implementation of . - - Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. - - The behavior of the mock with regards to the setups and the actual calls is determined - by the optional that can be passed to the - constructor. - - Type to mock, which can be an interface or a class. - The following example shows establishing setups with specific values - for method invocations: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - mock.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.True(order.IsFilled); - - The following example shows how to use the class - to specify conditions for arguments instead of specific values: - - // Arrange - var order = new Order(TALISKER, 50); - var mock = new Mock<IWarehouse>(); - - // shows how to expect a value within a range - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - // shows how to throw for unexpected calls. - mock.Setup(x => x.Remove( - It.IsAny<string>(), - It.IsAny<int>())) - .Throws(new InvalidOperationException()); - - // Act - order.Fill(mock.Object); - - // Assert - Assert.False(order.IsFilled); - - - - - - Base class for mocks and static helper class with methods that - apply to mocked objects, such as to - retrieve a from an object instance. - - - - - Helper interface used to hide the base - members from the fluent API to make it much cleaner - in Visual Studio intellisense. - - - - - - - - - - - - - - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the specification of how the mocked object should behave. - The type of the mocked object. - The mocked object created. - - - - Initializes a new instance of the class. - - - - - Retrieves the mock object for the given object instance. - - Type of the mock to retrieve. Can be omitted as it's inferred - from the object instance passed in as the instance. - The instance of the mocked object.The mock associated with the mocked object. - The received instance - was not created by Moq. - - The following example shows how to add a new setup to an object - instance which is not the original but rather - the object associated with it: - - // Typed instance, not the mock, is retrieved from some test API. - HttpContextBase context = GetMockContext(); - - // context.Request is the typed object from the "real" API - // so in order to add a setup to it, we need to get - // the mock that "owns" it - Mock<HttpRequestBase> request = Mock.Get(context.Request); - mock.Setup(req => req.AppRelativeCurrentExecutionFilePath) - .Returns(tempUrl); - - - - - - Returns the mocked object value. - - - - - Verifies that all verifiable expectations have been met. - - This example sets up an expectation and marks it as verifiable. After - the mock is used, a Verify() call is issued on the mock - to ensure the method in the setup was invoked: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Verifiable().Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory. - this.Verify(); - - Not all verifiable expectations were met. - - - - Verifies all expectations regardless of whether they have - been flagged as verifiable. - - This example sets up an expectation without marking it as verifiable. After - the mock is used, a call is issued on the mock - to ensure that all expectations are met: - - var mock = new Mock<IWarehouse>(); - this.Setup(x => x.HasInventory(TALISKER, 50)).Returns(true); - ... - // other test code - ... - // Will throw if the test code has didn't call HasInventory, even - // that expectation was not marked as verifiable. - this.VerifyAll(); - - At least one expectation was not met. - - - - Gets the interceptor target for the given expression and root mock, - building the intermediate hierarchy of mock objects if necessary. - - - - - Raises the associated event with the given - event argument data. - - - - - Raises the associated event with the given - event argument data. - - - - - Adds an interface implementation to the mock, - allowing setups to be specified for it. - - This method can only be called before the first use - of the mock property, at which - point the runtime type has already been generated - and no more interfaces can be added to it. - - Also, must be an - interface and not a class, which must be specified - when creating the mock instead. - - - The mock type - has already been generated by accessing the property. - - The specified - is not an interface. - - The following example creates a mock for the main interface - and later adds to it to verify - it's called by the consumer code: - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - // add IDisposable interface - var disposable = mock.As<IDisposable>(); - disposable.Setup(d => d.Dispose()).Verifiable(); - - Type of interface to cast the mock to. - - - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocked object instance. - - - - - Retrieves the type of the mocked object, its generic type argument. - This is used in the auto-mocking of hierarchy access. - - - - - If this is a mock of a delegate, this property contains the method - on the autogenerated interface so that we can convert setup + verify - expressions on the delegate into expressions on the interface proxy. - - - - - Allows to check whether expression conversion to the - must be performed on the mock, without causing unnecessarily early initialization of - the mock instance, which breaks As{T}. - - - - - Specifies the class that will determine the default - value to return when invocations are made that - have no setups and need to return a default - value (for loose mocks). - - - - - Exposes the list of extra interfaces implemented by the mock. - - - - - Covarient interface for Mock<T> such that casts between IMock<Employee> to IMock<Person> - are possible. Only covers the covariant members of Mock<T>. - - - - - Exposes the mocked object instance. - - - - - Behavior of the mock, according to the value set in the constructor. - - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Ctor invoked by AsTInterface exclusively. - - - - - Initializes an instance of the mock with default behavior. - - var mock = new Mock<IFormatProvider>(); - - - - - Initializes an instance of the mock with default behavior and with - the given constructor arguments for the class. (Only valid when is a class) - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only for classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Optional constructor arguments if the mocked type is a class. - - - - Initializes an instance of the mock with the specified behavior. - - var mock = new Mock<IFormatProvider>(MockBehavior.Relaxed); - Behavior of the mock. - - - - Initializes an instance of the mock with a specific behavior with - the given constructor arguments for the class. - - The mock will try to find the best match constructor given the constructor arguments, and invoke that - to initialize the instance. This applies only to classes, not interfaces. - - var mock = new Mock<MyProvider>(someArgument, 25); - Behavior of the mock.Optional constructor arguments if the mocked type is a class. - - - - Returns the name of the mock - - - - - Returns the mocked object value. - - - - - Specifies a setup on the mocked type for a call to - to a void method. - - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the expected method invocation. - - var mock = new Mock<IProcessor>(); - mock.Setup(x => x.Execute("ping")); - - - - - - Specifies a setup on the mocked type for a call to - to a value returning method. - Type of the return value. Typically omitted as it can be inferred from the expression. - If more than one setup is specified for the same method or property, - the latest one wins and is the one that will be executed. - Lambda expression that specifies the method invocation. - - mock.Setup(x => x.HasInventory("Talisker", 50)).Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property getter. - - If more than one setup is set for the same property getter, - the latest one wins and is the one that will be executed. - Type of the property. Typically omitted as it can be inferred from the expression.Lambda expression that specifies the property getter. - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - This overloads allows the use of a callback already - typed for the property type. - - Type of the property. Typically omitted as it can be inferred from the expression.The Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies a setup on the mocked type for a call to - to a property setter. - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - Lambda expression that sets a property to a value. - - mock.SetupSet(x => x.Suspended = true); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.Stub(v => v.Value); - - After the Stub call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - - v.Value = 5; - Assert.Equal(5, v.Value); - - - - - - Specifies that the given property should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. This overload - allows setting the initial value for the property. (this is also - known as "stubbing"). - - Type of the property, inferred from the property - expression (does not need to be specified). - Property expression to stub.Initial value for the property. - If you have an interface with an int property Value, you might - stub it using the following straightforward call: - - var mock = new Mock<IHaveValue>(); - mock.SetupProperty(v => v.Value, 5); - - After the SetupProperty call has been issued, setting and - retrieving the object value will behave as expected: - - IHaveValue v = mock.Object; - // Initial value was stored - Assert.Equal(5, v.Value); - - // New value set which changes the initial value - v.Value = 6; - Assert.Equal(6, v.Value); - - - - - - Specifies that the all properties on the mock should have "property behavior", - meaning that setting its value will cause it to be saved and - later returned when the property is requested. (this is also - known as "stubbing"). The default value for each property will be the - one generated as specified by the property for the mock. - - If the mock is set to , - the mocked default values will also get all properties setup recursively. - - - - - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IProcessor>(); - // exercise mock - //... - // Will throw if the test code didn't call Execute with a "ping" string argument. - mock.Verify(proc => proc.Execute("ping")); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock, - specifying a failure error message. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails. - - - - Verifies that a specific invocation matching the given expression was performed on the mock. Use - in conjunction with the default . - - This example assumes that the mock has been used, and later we want to verify that a given - invocation with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50)); - - The invocation was not performed on the mock.Expression to verify.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock. Use in conjunction - with the default . - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't call HasInventory. - mock.Verify(warehouse => warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a specific invocation matching the given - expression was performed on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - Expression to verify.The number of times a method is allowed to be called.Message to show if verification fails.Type of return value from the expression. - - - - Verifies that a property was read on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was retrieved from it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't retrieve the IsClosed property. - mock.VerifyGet(warehouse => warehouse.IsClosed); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was read on the mock, specifying a failure - error message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - - Verifies that a property was set on the mock. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true); - - The invocation was not performed on the mock.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - This example assumes that the mock has been used, - and later we want to verify that a given property - was set on it: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed = true, "Warehouse should always be closed after the action"); - - The invocation was not performed on the mock.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Verifies that a property was set on the mock, specifying - a failure message. - - The invocation was not call the times specified by - . - The number of times a method is allowed to be called.Expression to verify.Message to show if verification fails. - - - - Raises the event referenced in using - the given argument. - - The argument is - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a event: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.PropertyChanged -= null, new PropertyChangedEventArgs("Name")); - - - This example shows how to invoke an event with a custom event arguments - class in a view that will cause its corresponding presenter to - react by changing its state: - - var mockView = new Mock<IOrdersView>(); - var presenter = new OrdersPresenter(mockView.Object); - - // Check that the presenter has no selection by default - Assert.Null(presenter.SelectedOrder); - - // Raise the event with a specific arguments data - mockView.Raise(v => v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) }); - - // Now the presenter reacted to the event, and we have a selected order - Assert.NotNull(presenter.SelectedOrder); - Assert.Equal("moq", presenter.SelectedOrder.ProductName); - - - - - - Raises the event referenced in using - the given argument for a non-EventHandler typed event. - - The arguments are - invalid for the target event invocation, or the is - not an event attach or detach expression. - - The following example shows how to raise a custom event that does not adhere to - the standard EventHandler: - - var mock = new Mock<IViewModel>(); - - mock.Raise(x => x.MyEvent -= null, "Name", bool, 25); - - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Exposes the mocked object instance. - - - - - Allows naming of your mocks, so they can be easily identified in error messages (e.g. from failed assertions). - - - - - - - - Implements the fluent API. - - - - - The expectation will be considered only in the former condition. - - - - - - - The expectation will be considered only in the former condition. - - - - - - - - Setups the get. - - The type of the property. - The expression. - - - - - Setups the set. - - The type of the property. - The setter expression. - - - - - Setups the set. - - The setter expression. - - - - - Determines the way default values are generated - calculated for loose mocks. - - - - - Default behavior, which generates empty values for - value types (i.e. default(int)), empty array and - enumerables, and nulls for all other reference types. - - - - - Whenever the default value generated by - is null, replaces this value with a mock (if the type - can be mocked). - - - For sealed classes, a null value will be generated. - - - - - A that returns an empty default value - for invocations that do not have setups or return values, with loose mocks. - This is the default behavior for a mock. - - - - - Interface to be implemented by classes that determine the - default value of non-expected invocations. - - - - - Defines the default value to return in all the methods returning . - The type of the return value.The value to set as default. - - - - Provides a value for the given member and arguments. - - The member to provide a default value for. - - - - - Provides partial evaluation of subtrees, whenever they can be evaluated locally. - - Matt Warren: http://blogs.msdn.com/mattwar - Documented by InSTEDD: http://www.instedd.org - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A function that decides whether a given expression - node can be part of the local function. - A new tree with sub-trees evaluated and replaced. - - - - Performs evaluation and replacement of independent sub-trees - - The root of the expression tree. - A new tree with sub-trees evaluated and replaced. - - - - Evaluates and replaces sub-trees when first candidate is reached (top-down) - - - - - Performs bottom-up analysis to determine which nodes can possibly - be part of an evaluated sub-tree. - - - - - Casts the expression to a lambda expression, removing - a cast if there's any. - - - - - Casts the body of the lambda expression to a . - - If the body is not a method call. - - - - Converts the body of the lambda expression into the referenced by it. - - - - - Checks whether the body of the lambda expression is a property access. - - - - - Checks whether the expression is a property access. - - - - - Checks whether the body of the lambda expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Checks whether the expression is a property indexer, which is true - when the expression is an whose - has - equal to . - - - - - Creates an expression that casts the given expression to the - type. - - - - - TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 - is fixed. - - - - - Extracts, into a common form, information from a - around either a (for a normal method call) - or a (for a delegate invocation). - - - - - The intention of is to create a more readable - string representation for the failure message. - - - - - Tests if a type is a delegate type (subclasses ). - - - - - Tracks the current mock and interception context. - - - - - Having an active fluent mock context means that the invocation - is being performed in "trial" mode, just to gather the - target method and arguments that need to be matched later - when the actual invocation is made. - - - - - Ensures the given is not null. - Throws otherwise. - - - - - Ensures the given string is not null or empty. - Throws in the first case, or - in the latter. - - - - - Checks an argument to ensure it is in the specified range including the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Checks an argument to ensure it is in the specified range excluding the edges. - - Type of the argument to check, it must be an type. - - The expression containing the name of the argument. - The argument value to check. - The minimun allowed value for the argument. - The maximun allowed value for the argument. - - - - Handle interception - - the current invocation context - shared data for the interceptor as a whole - shared data among the strategies during a single interception - InterceptionAction.Continue if further interception has to be processed, otherwise InterceptionAction.Stop - - - - Implemented by all generated mock object instances. - - - - - Implemented by all generated mock object instances. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Reference the Mock that contains this as the mock.Object value. - - - - - Implements the actual interception and method invocation for - all mocks. - - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - - Name of the event, with the set_ or get_ prefix already removed - - - - Get an eventInfo for a given event name. Search type ancestors depth first if necessary. - Searches also in non public events. - - Name of the event, with the set_ or get_ prefix already removed - - - - Given a type return all of its ancestors, both types and interfaces. - - The type to find immediate ancestors of - - - - Allows the specification of a matching condition for an - argument in a method invocation, rather than a specific - argument value. "It" refers to the argument being matched. - - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate. - - - - - Matches any value of the given type. - - Typically used when the actual argument value for a method - call is not relevant. - - - // Throws an exception for a call to Remove with any string value. - mock.Setup(x => x.Remove(It.IsAny<string>())).Throws(new InvalidOperationException()); - - Type of the value. - - - - Matches any value of the given type, except null. - Type of the value. - - - - Matches any value that satisfies the given predicate. - Type of the argument to check.The predicate used to match the method argument. - Allows the specification of a predicate to perform matching - of method call arguments. - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Setup(x => x.Do(It.Is<int>(i => i % 2 == 0))) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Setup(x => x.GetUser(It.Is<int>(i => i < 0))) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - Type of the argument to check.The lower bound of the range.The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsInRange(0, 100, Range.Inclusive))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with value from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(values))) - .Returns(false); - - - - - - Matches any value that is present in the sequence specified. - Type of the argument to check.The sequence of possible values. - The following example shows how to expect a method call - with an integer argument with a value of 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsIn(1, 2, 3))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument with value not found from a list. - - var values = new List<int> { 1, 2, 3 }; - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(values))) - .Returns(false); - - - - - - Matches any value that is not found in the sequence specified. - Type of the argument to check.The sequence of disallowed values. - The following example shows how to expect a method call - with an integer argument of any value except 1, 2, or 3. - - mock.Setup(x => x.HasInventory( - It.IsAny<string>(), - It.IsNotIn(1, 2, 3))) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+"))).Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - The pattern to use to match the string argument value.The options used to interpret the pattern. - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Setup(x => x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1); - - - - - - Implements the fluent API. - - - - - Defines the Callback verb and overloads. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean - value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true); - - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The argument type of the invoked method. - The callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback((string command) => Console.WriteLine(command)); - - - - - - Defines occurrence members to constraint setups. - - - - - The expected invocation can happen at most once. - - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMostOnce(); - - - - - - The expected invocation can happen at most specified number of times. - - The number of times to accept calls. - - - var mock = new Mock<ICommand>(); - mock.Setup(foo => foo.Execute("ping")) - .AtMost( 5 ); - - - - - - Defines the Raises verb. - - - - - Specifies the event that will be raised - when the setup is met. - - An expression that represents an event attach or detach action. - The event arguments to pass for the raised event. - - The following example shows how to raise an event when - the setup is met: - - var mock = new Mock<IContainer>(); - - mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>())) - .Raises(add => add.Added += null, EventArgs.Empty); - - - - - - Specifies the event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - A function that will build the - to pass when raising the event. - - - - - Specifies the custom event that will be raised - when the setup is matched. - - An expression that represents an event attach or detach action. - The arguments to pass to the custom delegate (non EventHandler-compatible). - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - - - - - Specifies the event that will be raised when the setup is matched. - - The expression that represents an event attach or detach action. - The function that will build the - to pass when raising the event. - The type of the first argument received by the expected invocation. - The type of the second argument received by the expected invocation. - The type of the third argument received by the expected invocation. - The type of the fourth argument received by the expected invocation. - The type of the fifth argument received by the expected invocation. - The type of the sixth argument received by the expected invocation. - The type of the seventh argument received by the expected invocation. - The type of the eighth argument received by the expected invocation. - The type of the nineth argument received by the expected invocation. - The type of the tenth argument received by the expected invocation. - The type of the eleventh argument received by the expected invocation. - The type of the twelfth argument received by the expected invocation. - The type of the thirteenth argument received by the expected invocation. - The type of the fourteenth argument received by the expected invocation. - The type of the fifteenth argument received by the expected invocation. - The type of the sixteenth argument received by the expected invocation. - - - - - Defines the Verifiable verb. - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable(); - - - - - - Marks the expectation as verifiable, meaning that a call - to will check if this particular - expectation was met, and specifies a message for failures. - - - The following example marks the expectation as verifiable: - - mock.Expect(x => x.Execute("ping")) - .Returns(true) - .Verifiable("Ping should be executed always!"); - - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Throws verb. - - - - - Specifies the exception to throw when the method is invoked. - - Exception instance to throw. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws(new ArgumentException()); - - - - - - Specifies the type of exception to throw when the method is invoked. - - Type of exception to instantiate and throw when the setup is matched. - - This example shows how to throw an exception when the method is - invoked with an empty string argument: - - mock.Setup(x => x.Execute("")) - .Throws<ArgumentException>(); - - - - - - Implements the fluent API. - - - - - Implements the fluent API. - - - - - Defines the Callback verb and overloads for callbacks on - setups that return a value. - - Mocked type. - Type of the return value of the setup. - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2) => Console.WriteLine(arg1 + arg2)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3) => Console.WriteLine(arg1 + arg2 + arg3)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15)); - - - - - - Specifies a callback to invoke when the method is called that receives the original - arguments. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The callback method to invoke. - A reference to interface. - - Invokes the given callback with the concrete invocation arguments values. - - Notice how the specific arguments are retrieved by simply declaring - them as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute( - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>(), - It.IsAny<string>())) - .Callback((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16) => Console.WriteLine(arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16)); - - - - - - Specifies a callback to invoke when the method is called. - - The callback method to invoke. - - The following example specifies a callback to set a boolean value that can be used later: - - var called = false; - mock.Setup(x => x.Execute()) - .Callback(() => called = true) - .Returns(true); - - Note that in the case of value-returning methods, after the Callback - call you can still specify the return value. - - - - - Specifies a callback to invoke when the method is called that receives the original arguments. - - The type of the argument of the invoked method. - Callback method to invoke. - - Invokes the given callback with the concrete invocation argument value. - - Notice how the specific string argument is retrieved by simply declaring - it as part of the lambda expression for the callback: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Callback(command => Console.WriteLine(command)) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb. - - Mocked type. - Type of the return value from the expression. - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2) => arg1 + arg2); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3) => arg1 + arg2 + arg3); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4) => arg1 + arg2 + arg3 + arg4); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5) => arg1 + arg2 + arg3 + arg4 + arg5); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15); - - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the first argument of the invoked method. - The type of the second argument of the invoked method. - The type of the third argument of the invoked method. - The type of the fourth argument of the invoked method. - The type of the fifth argument of the invoked method. - The type of the sixth argument of the invoked method. - The type of the seventh argument of the invoked method. - The type of the eighth argument of the invoked method. - The type of the nineth argument of the invoked method. - The type of the tenth argument of the invoked method. - The type of the eleventh argument of the invoked method. - The type of the twelfth argument of the invoked method. - The type of the thirteenth argument of the invoked method. - The type of the fourteenth argument of the invoked method. - The type of the fifteenth argument of the invoked method. - The type of the sixteenth argument of the invoked method. - The function that will calculate the return value. - Returns a calculated value which is evaluated lazily at the time of the invocation. - - - The return value is calculated from the value of the actual method invocation arguments. - Notice how the arguments are retrieved by simply declaring them as part of the lambda - expression: - - - mock.Setup(x => x.Execute( - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>(), - It.IsAny<int>())) - .Returns((string arg1, string arg2, string arg3, string arg4, string arg5, string arg6, string arg7, string arg8, string arg9, string arg10, string arg11, string arg12, string arg13, string arg14, string arg15, string arg16) => arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15 + arg16); - - - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the method call: - - mock.Setup(x => x.Execute("ping")) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return from the method. - - The function that will calculate the return value. - - Return a calculated value when the method is called: - - mock.Setup(x => x.Execute("ping")) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the method - is executed and the value the returnValues array has at - that moment. - - - - - Specifies a function that will calculate the value to return from the method, - retrieving the arguments for the invocation. - - The type of the argument of the invoked method. - The function that will calculate the return value. - - Return a calculated value which is evaluated lazily at the time of the invocation. - - The lookup list can change between invocations and the setup - will return different values accordingly. Also, notice how the specific - string argument is retrieved by simply declaring it as part of the lambda - expression: - - - mock.Setup(x => x.Execute(It.IsAny<string>())) - .Returns((string command) => returnValues[command]); - - - - - - Calls the real method of the object and returns its return value. - - The value calculated by the real method of the object. - - - - Implements the fluent API. - - - - - Defines the Callback verb for property getter setups. - - - Mocked type. - Type of the property. - - - - Specifies a callback to invoke when the property is retrieved. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupGet(x => x.Suspended) - .Callback(() => called = true) - .Returns(true); - - - - - - Implements the fluent API. - - - - - Defines the Returns verb for property get setups. - - Mocked type. - Type of the property. - - - - Specifies the value to return. - - The value to return, or . - - Return a true value from the property getter call: - - mock.SetupGet(x => x.Suspended) - .Returns(true); - - - - - - Specifies a function that will calculate the value to return for the property. - - The function that will calculate the return value. - - Return a calculated value when the property is retrieved: - - mock.SetupGet(x => x.Suspended) - .Returns(() => returnValues[0]); - - The lambda expression to retrieve the return value is lazy-executed, - meaning that its value may change depending on the moment the property - is retrieved and the value the returnValues array has at - that moment. - - - - - Calls the real property of the object and returns its return value. - - The value calculated by the real property of the object. - - - - Implements the fluent API. - - - - - Defines the Callback verb for property setter setups. - - Type of the property. - - - - Specifies a callback to invoke when the property is set that receives the - property value being set. - - Callback method to invoke. - - Invokes the given callback with the property value being set. - - mock.SetupSet(x => x.Suspended) - .Callback((bool state) => Console.WriteLine(state)); - - - - - - Language for ReturnSequence - - - - - Returns value - - - - - Throws an exception - - - - - Throws an exception - - - - - Calls original method - - - - - The first method call or member access will be the - last segment of the expression (depth-first traversal), - which is the one we have to Setup rather than FluentMock. - And the last one is the one we have to Mock.Get rather - than FluentMock. - - - - - A default implementation of IQueryable for use with QueryProvider - - - - - The is a - static method that returns an IQueryable of Mocks of T which is used to - apply the linq specification to. - - - - - Utility repository class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the repository constructor) and later verifying each - mock can become repetitive and tedious. - - This repository class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var repository = new MockRepository(MockBehavior.Strict); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - repository.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the repository - to create loose mocks and later verify only verifiable setups: - - var repository = new MockRepository(MockBehavior.Loose); - - var foo = repository.Create<IFoo>(); - var bar = repository.Create<IBar>(); - - // this setup will be verified when we verify the repository - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the repository - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - repository.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the repository with a - default strict behavior, overriding that default for a - specific mock: - - var repository = new MockRepository(MockBehavior.Strict); - - // this particular one we want loose - var foo = repository.Create<IFoo>(MockBehavior.Loose); - var bar = repository.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - repository.Verify(); - - - - - - - Utility factory class to use to construct multiple - mocks when consistent verification is - desired for all of them. - - - If multiple mocks will be created during a test, passing - the desired (if different than the - or the one - passed to the factory constructor) and later verifying each - mock can become repetitive and tedious. - - This factory class helps in that scenario by providing a - simplified creation of multiple mocks with a default - (unless overriden by calling - ) and posterior verification. - - - - The following is a straightforward example on how to - create and automatically verify strict mocks using a : - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // no need to call Verifiable() on the setup - // as we'll be validating all of them anyway. - foo.Setup(f => f.Do()); - bar.Setup(b => b.Redo()); - - // exercise the mocks here - - factory.VerifyAll(); - // At this point all setups are already checked - // and an optional MockException might be thrown. - // Note also that because the mocks are strict, any invocation - // that doesn't have a matching setup will also throw a MockException. - - The following examples shows how to setup the factory - to create loose mocks and later verify only verifiable setups: - - var factory = new MockFactory(MockBehavior.Loose); - - var foo = factory.Create<IFoo>(); - var bar = factory.Create<IBar>(); - - // this setup will be verified when we verify the factory - foo.Setup(f => f.Do()).Verifiable(); - - // this setup will NOT be verified - foo.Setup(f => f.Calculate()); - - // this setup will be verified when we verify the factory - bar.Setup(b => b.Redo()).Verifiable(); - - // exercise the mocks here - // note that because the mocks are Loose, members - // called in the interfaces for which no matching - // setups exist will NOT throw exceptions, - // and will rather return default values. - - factory.Verify(); - // At this point verifiable setups are already checked - // and an optional MockException might be thrown. - - The following examples shows how to setup the factory with a - default strict behavior, overriding that default for a - specific mock: - - var factory = new MockFactory(MockBehavior.Strict); - - // this particular one we want loose - var foo = factory.Create<IFoo>(MockBehavior.Loose); - var bar = factory.Create<IBar>(); - - // specify setups - - // exercise the mocks here - - factory.Verify(); - - - - - - - Initializes the factory with the given - for newly created mocks from the factory. - - The behavior to use for mocks created - using the factory method if not overriden - by using the overload. - - - - Creates a new mock with the default - specified at factory construction time. - - Type to mock. - A new . - - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(); - // use mock on tests - - factory.VerifyAll(); - - - - - - Creates a new mock with the default - specified at factory construction time and with the - the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Constructor arguments for mocked classes. - A new . - - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>("Foo", 25, true); - // use mock on tests - - factory.Verify(); - - - - - - Creates a new mock with the given . - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory: - - var factory = new MockFactory(MockBehavior.Strict); - - var foo = factory.Create<IFoo>(MockBehavior.Loose); - - - - - - Creates a new mock with the given - and with the the given constructor arguments for the class. - - - The mock will try to find the best match constructor given the - constructor arguments, and invoke that to initialize the instance. - This applies only to classes, not interfaces. - - Type to mock. - Behavior to use for the mock, which overrides - the default behavior specified at factory construction time. - Constructor arguments for mocked classes. - A new . - - The following example shows how to create a mock with a different - behavior to that specified as the default for the factory, passing - constructor arguments: - - var factory = new MockFactory(MockBehavior.Default); - - var mock = factory.Create<MyBase>(MockBehavior.Strict, "Foo", 25, true); - - - - - - Implements creation of a new mock within the factory. - - Type to mock. - The behavior for the new mock. - Optional arguments for the construction of the mock. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Verifies all verifiable expectations on all mocks created - by this factory. - - - One or more mocks had expectations that were not satisfied. - - - - Invokes for each mock - in , and accumulates the resulting - that might be - thrown from the action. - - The action to execute against - each mock. - - - - Whether the base member virtual implementation will be called - for mocked classes if no setup is matched. Defaults to . - - - - - Specifies the behavior to use when returning default values for - unexpected invocations on loose mocks. - - - - - Gets the mocks that have been created by this factory and - that will get verified together. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Initializes the repository with the given - for newly created mocks from the repository. - - The behavior to use for mocks created - using the repository method if not overriden - by using the overload. - - - - Allows querying the universe of mocks for those that behave - according to the LINQ query specification. - - - This entry-point into Linq to Mocks is the only one in the root Moq - namespace to ease discovery. But to get all the mocking extension - methods on Object, a using of Moq.Linq must be done, so that the - polluting of the intellisense for all objects is an explicit opt-in. - - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The type of the mocked object to query. - - - - Access the universe of mocks of the given type, to retrieve those - that behave according to the LINQ query specification. - - The predicate with the setup expressions. - The type of the mocked object to query. - - - - Creates an mock object of the indicated type. - - The type of the mocked object. - The mocked object created. - - - - Creates an mock object of the indicated type. - - The predicate with the setup expressions. - The type of the mocked object. - The mocked object created. - - - - Creates the mock query with the underlying queriable implementation. - - - - - Wraps the enumerator inside a queryable. - - - - - Method that is turned into the actual call from .Query{T}, to - transform the queryable query into a normal enumerable query. - This method is never used directly by consumers. - - - - - Extension method used to support Linq-like setup properties that are not virtual but do have - a getter and a setter, thereby allowing the use of Linq to Mocks to quickly initialize Dtos too :) - - - - - Helper extensions that are used by the query translator. - - - - - Retrieves a fluent mock from the given setup expression. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - - See also . - - - - - Provided for the sole purpose of rendering the delegate passed to the - matcher constructor if no friendly render lambda is provided. - - - - - Initializes the match with the condition that - will be checked in order to match invocation - values. - The condition to match against actual values. - - - - - - - - - This method is used to set an expression as the last matcher invoked, - which is used in the SetupSet to allow matchers in the prop = value - delegate expression. This delegate is executed in "fluent" mode in - order to capture the value being set, and construct the corresponding - methodcall. - This is also used in the MatcherFactory for each argument expression. - This method ensures that when we execute the delegate, we - also track the matcher that was invoked, so that when we create the - methodcall we build the expression using it, rather than the null/default - value returned from the actual invocation. - - - - - Allows creation custom value matchers that can be used on setups and verification, - completely replacing the built-in class with your own argument - matching rules. - Type of the value to match. - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - Creating a custom matcher is straightforward. You just need to create a method - that returns a value from a call to with - your matching condition and optional friendly render expression: - - [Matcher] - public Order IsBigOrder() - { - return Match<Order>.Create( - o => o.GrandTotal >= 5000, - /* a friendly expression to render on failures */ - () => IsBigOrder()); - } - - This method can be used in any mock setup invocation: - - mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>(); - - At runtime, Moq knows that the return value was a matcher (note that the method MUST be - annotated with the [Matcher] attribute in order to determine this) and - evaluates your predicate with the actual value passed into your predicate. - - Another example might be a case where you want to match a lists of orders - that contains a particular one. You might create matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return Match<IEnumerable<Order>>.Create(orders => orders.Contains(order)); - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - - - - - Marks a method as a matcher, which allows complete replacement - of the built-in class with your own argument - matching rules. - - - This feature has been deprecated in favor of the new - and simpler . - - - The argument matching is used to determine whether a concrete - invocation in the mock matches a given setup. This - matching mechanism is fully extensible. - - - There are two parts of a matcher: the compiler matcher - and the runtime matcher. - - - Compiler matcher - Used to satisfy the compiler requirements for the - argument. Needs to be a method optionally receiving any arguments - you might need for the matching, but with a return type that - matches that of the argument. - - Let's say I want to match a lists of orders that contains - a particular one. I might create a compiler matcher like the following: - - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - } - - Now we can invoke this static method instead of an argument in an - invocation: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - Note that the return value from the compiler matcher is irrelevant. - This method will never be called, and is just used to satisfy the - compiler and to signal Moq that this is not a method that we want - to be invoked at runtime. - - - - Runtime matcher - - The runtime matcher is the one that will actually perform evaluation - when the test is run, and is defined by convention to have the - same signature as the compiler matcher, but where the return - value is the first argument to the call, which contains the - object received by the actual invocation at runtime: - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - - At runtime, the mocked method will be invoked with a specific - list of orders. This value will be passed to this runtime - matcher as the first argument, while the second argument is the - one specified in the setup (x.Save(Orders.Contains(order))). - - The boolean returned determines whether the given argument has been - matched. If all arguments to the expected method are matched, then - the setup matches and is evaluated. - - - - - - Using this extensible infrastructure, you can easily replace the entire - set of matchers with your own. You can also avoid the - typical (and annoying) lengthy expressions that result when you have - multiple arguments that use generics. - - - The following is the complete example explained above: - - public static class Orders - { - [Matcher] - public static IEnumerable<Order> Contains(Order order) - { - return null; - } - - public static bool Contains(IEnumerable<Order> orders, Order order) - { - return orders.Contains(order); - } - } - - And the concrete test using this matcher: - - var order = new Order { ... }; - var mock = new Mock<IRepository<Order>>(); - - mock.Setup(x => x.Save(Orders.Contains(order))) - .Throws<ArgumentException>(); - - // use mock, invoke Save, and have the matcher filter. - - - - - - Matcher to treat static functions as matchers. - - mock.Setup(x => x.StringMethod(A.MagicString())); - - public static class A - { - [Matcher] - public static string MagicString() { return null; } - public static bool MagicString(string arg) - { - return arg == "magic"; - } - } - - Will succeed if: mock.Object.StringMethod("magic"); - and fail with any other call. - - - - - We need this non-generics base class so that - we can use from - generic code. - - - - - Options to customize the behavior of the mock. - - - - - Causes the mock to always throw - an exception for invocations that don't have a - corresponding setup. - - - - - Will never throw exceptions, returning default - values when necessary (null for reference types, - zero for value types or empty enumerables and arrays). - - - - - Default mock behavior, which equals . - - - - - A that returns an empty default value - for non-mockeable types, and mocks for all other types (interfaces and - non-sealed classes) that can be mocked. - - - - - Exception thrown by mocks when setups are not matched, - the mock is not properly setup, etc. - - - A distinct exception type is provided so that exceptions - thrown by the mock can be differentiated in tests that - expect other exceptions to be thrown (i.e. ArgumentException). - - Richer exception hierarchy/types are not provided as - tests typically should not catch or expect exceptions - from the mocks. These are typically the result of changes - in the tested class or its collaborators implementation, and - result in fixes in the mock setup so that they dissapear and - allow the test to pass. - - - - - - Indicates whether this exception is a verification fault raised by Verify() - - - - - Made internal as it's of no use for - consumers, but it's important for - our own tests. - - - - - Used by the mock factory to accumulate verification - failures. - - - - - Helper class to setup a full trace between many mocks - - - - - Initialize a trace setup - - - - - Allow sequence to be repeated - - - - - define nice api - - - - - Perform an expectation in the trace. - - - - - Provides legacy API members as extensions so that - existing code continues to compile, but new code - doesn't see then. - - - - - Obsolete. - - - - - Obsolete. - - - - - Obsolete. - - - - - Provides additional methods on mocks. - - - Provided as extension methods as they confuse the compiler - with the overloads taking Action. - - - - - Specifies a setup on the mocked type for a call to - to a property setter, regardless of its value. - - - If more than one setup is set for the same property setter, - the latest one wins and is the one that will be executed. - - Type of the property. Typically omitted as it can be inferred from the expression. - Type of the mock. - The target mock for the setup. - Lambda expression that specifies the property setter. - - - mock.SetupSet(x => x.Suspended); - - - - This method is not legacy, but must be on an extension method to avoid - confusing the compiler with the new Action syntax. - - - - - Verifies that a property has been set on the mock, regarless of its value. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - Expression to verify. - Message to show if verification fails. - The mock instance. - Mocked type. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Verifies that a property has been set on the mock, regardless - of the value but only the specified number of times, and specifying a failure - error message. - - - This example assumes that the mock has been used, - and later we want to verify that a given invocation - with specific parameters was performed: - - var mock = new Mock<IWarehouse>(); - // exercise mock - //... - // Will throw if the test code didn't set the IsClosed property. - mock.VerifySet(warehouse => warehouse.IsClosed); - - - The invocation was not performed on the mock. - The invocation was not call the times specified by - . - The mock instance. - Mocked type. - The number of times a method is allowed to be called. - Message to show if verification fails. - Expression to verify. - Type of the property to verify. Typically omitted as it can - be inferred from the expression's return type. - - - - Allows setups to be specified for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Specifies a setup for a void method invocation with the given - , optionally specifying arguments for the method call. - - The name of the void method to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a setup for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The return type of the method or property. - - - - Specifies a setup for an invocation on a property getter with the given - . - - The name of the property. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The name of the property. - The property value. If argument matchers are used, - remember to use rather than . - The type of the property. - - - - Specifies a verify for a void method with the given , - optionally specifying arguments for the method call. Use in conjunction with the default - . - - The invocation was not call the times specified by - . - The name of the void method to be verified. - The number of times a method is allowed to be called. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - - - - Specifies a verify for an invocation on a property or a non void method with the given - , optionally specifying arguments for the method call. - - The invocation was not call the times specified by - . - The name of the method or property to be invoked. - The optional arguments for the invocation. If argument matchers are used, - remember to use rather than . - The number of times a method is allowed to be called. - The type of return value from the expression. - - - - Specifies a verify for an invocation on a property getter with the given - . - The invocation was not call the times specified by - . - - The name of the property. - The number of times a method is allowed to be called. - The type of the property. - - - - Specifies a setup for an invocation on a property setter with the given - . - - The invocation was not call the times specified by - . - The name of the property. - The number of times a method is allowed to be called. - The property value. - The type of the property. If argument matchers are used, - remember to use rather than . - - - - Allows the specification of a matching condition for an - argument in a protected member setup, rather than a specific - argument value. "ItExpr" refers to the argument being matched. - - - Use this variant of argument matching instead of - for protected setups. - This class allows the setup to match a method invocation - with an arbitrary value, with a value in a specified range, or - even one that matches a given predicate, or null. - - - - - Matches a null value of the given type. - - - Required for protected mocks as the null value cannot be used - directly as it prevents proper method overload selection. - - - - // Throws an exception for a call to Remove with a null string value. - mock.Protected() - .Setup("Remove", ItExpr.IsNull<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value of the given type. - - - Typically used when the actual argument value for a method - call is not relevant. - - - - // Throws an exception for a call to Remove with any string value. - mock.Protected() - .Setup("Remove", ItExpr.IsAny<string>()) - .Throws(new InvalidOperationException()); - - - Type of the value. - - - - Matches any value that satisfies the given predicate. - - Type of the argument to check. - The predicate used to match the method argument. - - Allows the specification of a predicate to perform matching - of method call arguments. - - - This example shows how to return the value 1 whenever the argument to the - Do method is an even number. - - mock.Protected() - .Setup("Do", ItExpr.Is<int>(i => i % 2 == 0)) - .Returns(1); - - This example shows how to throw an exception if the argument to the - method is a negative number: - - mock.Protected() - .Setup("GetUser", ItExpr.Is<int>(i => i < 0)) - .Throws(new ArgumentException()); - - - - - - Matches any value that is in the range specified. - - Type of the argument to check. - The lower bound of the range. - The upper bound of the range. - The kind of range. See . - - The following example shows how to expect a method call - with an integer argument within the 0..100 range. - - mock.Protected() - .Setup("HasInventory", - ItExpr.IsAny<string>(), - ItExpr.IsInRange(0, 100, Range.Inclusive)) - .Returns(false); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+")) - .Returns(1); - - - - - - Matches a string argument if it matches the given regular expression pattern. - - The pattern to use to match the string argument value. - The options used to interpret the pattern. - - The following example shows how to expect a call to a method where the - string argument matches the given regular expression, in a case insensitive way: - - mock.Protected() - .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase)) - .Returns(1); - - - - - - Enables the Protected() method on , - allowing setups to be set for protected members by using their - name as a string, rather than strong-typing them which is not possible - due to their visibility. - - - - - Enable protected setups for the mock. - - Mocked object type. Typically omitted as it can be inferred from the mock instance. - The mock to set the protected setups on. - - - - - - - - - - - - A strongly-typed resource class, for looking up localized strings, etc. - - - - - Returns the cached ResourceManager instance used by this class. - - - - - Overrides the current thread's CurrentUICulture property for all - resource lookups using this strongly typed resource class. - - - - - Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that.. - - - - - Looks up a localized string similar to Value cannot be an empty string.. - - - - - Looks up a localized string similar to Can only add interfaces to the mock.. - - - - - Looks up a localized string similar to Can't set return value for void method {0}.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for delegate mocks.. - - - - - Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks.. - - - - - Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type.. - - - - - Looks up a localized string similar to Could not locate event for attach or detach method {0}.. - - - - - Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead.. - - - - - Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. . - - - - - Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it's not the main type of the mock or any of its additional interfaces. - Please cast the argument to one of the supported types: {1}. - Remember that there's no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed.. - - - - - Looks up a localized string similar to The equals ("==" or "=" in VB) and the conditional 'and' ("&&" or "AndAlso" in VB) operators are the only ones supported in the query specification expression. Unsupported expression: {0}. - - - - - Looks up a localized string similar to LINQ method '{0}' not supported.. - - - - - Looks up a localized string similar to Expression contains a call to a method which is not virtual (overridable in VB) or abstract. Unsupported expression: {0}. - - - - - Looks up a localized string similar to Member {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead: - mock.Setup(x => x.{1}()); - . - - - - - Looks up a localized string similar to {0} invocation failed with mock behavior {1}. - {2}. - - - - - Looks up a localized string similar to Expected only {0} calls to {1}.. - - - - - Looks up a localized string similar to Expected only one call to {0}.. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at least once, but was never performed: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most {3} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock at most once, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Exclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock between {2} and {3} times (Inclusive), but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock exactly {2} times, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock should never have been performed, but was {4} times: {1}. - - - - - Looks up a localized string similar to {0} - Expected invocation on the mock once, but was {4} times: {1}. - - - - - Looks up a localized string similar to All invocations on the mock must have a corresponding setup.. - - - - - Looks up a localized string similar to Object instance was not created by Moq.. - - - - - Looks up a localized string similar to Out expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a getter.. - - - - - Looks up a localized string similar to Property {0}.{1} does not exist.. - - - - - Looks up a localized string similar to Property {0}.{1} is write-only.. - - - - - Looks up a localized string similar to Property {0}.{1} is read-only.. - - - - - Looks up a localized string similar to Property {0}.{1} does not have a setter.. - - - - - Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object.. - - - - - Looks up a localized string similar to Ref expression must evaluate to a constant value.. - - - - - Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it.. - - - - - Looks up a localized string similar to A lambda expression is expected as the argument to It.Is<T>.. - - - - - Looks up a localized string similar to Invocation {0} should not have been made.. - - - - - Looks up a localized string similar to Expression is not a method invocation: {0}. - - - - - Looks up a localized string similar to Expression is not a property access: {0}. - - - - - Looks up a localized string similar to Expression is not a property setter invocation.. - - - - - Looks up a localized string similar to Expression references a method that does not belong to the mocked object: {0}. - - - - - Looks up a localized string similar to Invalid setup on a non-virtual (overridable in VB) member: {0}. - - - - - Looks up a localized string similar to Type {0} does not implement required interface {1}. - - - - - Looks up a localized string similar to Type {0} does not from required type {1}. - - - - - Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as: - mock.Setup(x => x.{1}).Returns(value); - mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one - mock.SetupSet(x => x.{1}).Callback(callbackDelegate); - . - - - - - Looks up a localized string similar to Unsupported expression: {0}. - - - - - Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}.. - - - - - Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}.. - - - - - Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters.. - - - - - Looks up a localized string similar to Member {0} is not supported for protected mocking.. - - - - - Looks up a localized string similar to Setter expression can only use static custom matchers.. - - - - - Looks up a localized string similar to The following setups were not matched: - {0}. - - - - - Looks up a localized string similar to Invalid verify on a non-virtual (overridable in VB) member: {0}. - - - - - Gets an autogenerated interface with a method on it that matches the signature of the specified - . - - - Such an interface can then be mocked, and a delegate pointed at the method on the mocked instance. - This is how we support delegate mocking. The factory caches such interfaces and reuses them - for repeated requests for the same delegate type. - - The delegate type for which an interface is required. - The method on the autogenerated interface. - - - - - - - - - - Hook used to tells Castle which methods to proxy in mocked classes. - - Here we proxy the default methods Castle suggests (everything Object's methods) - plus Object.ToString(), so we can give mocks useful default names. - - This is required to allow Moq to mock ToString on proxy *class* implementations. - - - - - Extends AllMethodsHook.ShouldInterceptMethod to also intercept Object.ToString(). - - - - - The base class used for all our interface-inheriting proxies, which overrides the default - Object.ToString() behavior, to route it via the mock by default, unless overriden by a - real implementation. - - This is required to allow Moq to mock ToString on proxy *interface* implementations. - - - This is internal to Moq and should not be generally used. - - Unfortunately it must be public, due to cross-assembly visibility issues with reflection, - see github.com/Moq/moq4/issues/98 for details. - - - - - Overrides the default ToString implementation to instead find the mock for this mock.Object, - and return MockName + '.Object' as the mocked object's ToString, to make it easy to relate - mocks and mock object instances in error messages. - - - - - Kind of range to use in a filter specified through - . - - - - - The range includes the to and - from values. - - - - - The range does not include the to and - from values. - - - - - Defines async extension methods on IReturns. - - - - - Allows to specify the return value of an asynchronous method. - - - - - Allows to specify the exception thrown by an asynchronous method. - - - - - Helper for sequencing return values in the same method. - - - - - Return a sequence of values, once per call. - - - - - Defines the number of invocations allowed by a mocked method. - - - - - Specifies that a mocked method should be invoked times as minimum. - The minimun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as minimum. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked time as maximun. - The maximun number of times.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked one time as maximun. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked between and - times. - The minimun number of times.The maximun number of times. - The kind of range. See . - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly times. - The times that a method or property can be called.An object defining the allowed number of invocations. - - - - Specifies that a mocked method should not be invoked. - An object defining the allowed number of invocations. - - - - Specifies that a mocked method should be invoked exactly one time. - An object defining the allowed number of invocations. - - - - Determines whether the specified is equal to this instance. - - The to compare with this instance. - - true if the specified is equal to this instance; otherwise, false. - - - - - Returns a hash code for this instance. - - A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. - - - - - Determines whether two specified objects have the same value. - - The first . - - The second . - - true if the value of left is the same as the value of right; otherwise, false. - - - - - Determines whether two specified objects have different values. - - The first . - - The second . - - true if the value of left is different from the value of right; otherwise, false. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/SshNet.Security.Cryptography.1.1.0.nupkg b/packages/SshNet.Security.Cryptography.1.1.0/SshNet.Security.Cryptography.1.1.0.nupkg deleted file mode 100644 index 1310cf24b157d53257bb1bf0c43d79472f2396ea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 182529 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

5=r9 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

U`$jj7VYbo3K7H6P{` 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 z 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 - - - SshNet.Security.Cryptography - - - -

- Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.dll deleted file mode 100644 index db4ea77673cd09ee8b9144c180b700cf14287836..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37888 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 diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml deleted file mode 100644 index ef8f0efe..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/net40/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1163 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/net45/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/net45/SshNet.Security.Cryptography.dll deleted file mode 100644 index c8a845355445aad3b29dc3066eb4302a7ac134a0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37376 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 - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.dll deleted file mode 100644 index 2cea4205c36e08d0b25ca4029e4f08e78f688e6d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 39424 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 H(gObnuf7H< diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml deleted file mode 100644 index ec29c1a7..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.0/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1302 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Represents the base class from which all implementations of cryptographic - hash algorithms must derive. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets a value indicating whether the current transform can be reused. - - - Always true. - - - - - Gets a value indicating whether multiple blocks can be transformed. - - - true if multiple blocks can be transformed; otherwise, false. - - - - - Computes the hash value for the specified byte array. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the array to use as data. - - The computed hash code. - - - is an invalid value. - -or- - length is invalid. - - is out of range. This parameter requires a non-negative number. - is null. - The object has already been disposed. - - - - Computes the hash value for the specified object. - - The input to compute the hash code for. - - The computed hash code. - - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Represents the abstract class from which all implementations of keyed - hash algorithms must derive. - - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Releases the unmanaged resources used by the and - optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/netstandard1.3/SshNet.Security.Cryptography.dll deleted file mode 100644 index e26487c53feaf5b85011ad0a915b0ec3c5424885..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37888 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 m6CRA - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/portable-net45+win8+wpa81/SshNet.Security.Cryptography.dll deleted file mode 100644 index ad8c8a6ab60ebe42015923813af1df4f90a6739b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 38912 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 - - - SshNet.Security.Cryptography - - - - - Represents the base class from which all implementations of cryptographic - hash algorithms must derive. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets a value indicating whether the current transform can be reused. - - - Always true. - - - - - Gets a value indicating whether multiple blocks can be transformed. - - - true if multiple blocks can be transformed; otherwise, false. - - - - - Computes the hash value for the specified byte array. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the array to use as data. - - The computed hash code. - - - is an invalid value. - -or- - length is invalid. - - is out of range. This parameter requires a non-negative number. - is null. - The object has already been disposed. - - - - Computes the hash value for the specified object. - - The input to compute the hash code for. - - The computed hash code. - - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Represents the abstract class from which all implementations of keyed - hash algorithms must derive. - - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Releases the unmanaged resources used by the and - optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.dll deleted file mode 100644 index 4068317a26cc86d7852cfb9e40428d63914c7462..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37888 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 diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml deleted file mode 100644 index ef8f0efe..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl4/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1163 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/sl5/SshNet.Security.Cryptography.dll deleted file mode 100644 index 100ad619c2c7f604f513af37297196db51d6e2be..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37888 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 - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.dll deleted file mode 100644 index 434ca153da02b4ae2da160c184c438b023093261..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 39424 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 ANB{r; diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml deleted file mode 100644 index ec29c1a7..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/uap10.0/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1302 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Represents the base class from which all implementations of cryptographic - hash algorithms must derive. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets a value indicating whether the current transform can be reused. - - - Always true. - - - - - Gets a value indicating whether multiple blocks can be transformed. - - - true if multiple blocks can be transformed; otherwise, false. - - - - - Computes the hash value for the specified byte array. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the array to use as data. - - The computed hash code. - - - is an invalid value. - -or- - length is invalid. - - is out of range. This parameter requires a non-negative number. - is null. - The object has already been disposed. - - - - Computes the hash value for the specified object. - - The input to compute the hash code for. - - The computed hash code. - - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Represents the abstract class from which all implementations of keyed - hash algorithms must derive. - - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Releases the unmanaged resources used by the and - optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.dll deleted file mode 100644 index b9d0c7ab0372bc6321e4423ece6045b6ecb560ff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37376 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 diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml deleted file mode 100644 index ef8f0efe..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp71/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1163 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.dll b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.dll deleted file mode 100644 index 3d2ee74070dce6c9c96c3d685335c92b1303de49..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37376 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 YzprJ1JJowC>r1~D^*2QSpIhL60_XF)7ytkO diff --git a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.xml b/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.xml deleted file mode 100644 index ef8f0efe..00000000 --- a/packages/SshNet.Security.Cryptography.1.1.0/lib/wp8/SshNet.Security.Cryptography.xml +++ /dev/null @@ -1,1163 +0,0 @@ - - - - SshNet.Security.Cryptography - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - Releases all resources used by the current instance of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Provides HMAC algorithm implementation. - - - - - Gets the size of the block. - - - The size of the block. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Initializes a with the specified hash algorithm. - - The hash provider. - is null. - - - - Initializes a with the specified hash algorithm, key and size of the computed - hash code. - - The hash provider. - The key. - The size, in bits, of the computed hash code. - is null. - - - - Initializes a with the specified hash algorithm and key. - - The hash provider. - The key. - is null. - - - - Gets or sets the key to use in the hash algorithm. - - - The key to use in the hash algorithm. - - - - - Initializes an implementation of the class. - - - - - Hashes the core. - - The RGB. - The ib. - The cb. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Releases unmanaged and - optionally - managed resources - - true to release both managed and unmanaged resources; false to release only unmanaged ResourceMessages. - - - - Return a key that fits the of the . - - The key to shorten, if necessary. - - A hash of if is longer than the of the - ; otherwise, . - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 64 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Computes a Hash-based Message Authentication Code (HMAC) by using the hash function. - - - - - Initializes a with the specified key. - - The key. - - - - Initializes a with the specified key and size of the computed hash code. - - The key. - The size, in bits, of the computed hash code. - - - - Gets or sets the block size, in bytes, to use in the hash value. - - - The block size to use in the hash value. For this is 128 bytes. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Gets the value of the computed hash code. - - - The current value of the computed hash code. - - The object has already been disposed. - - - - Initializes an implementation of the . - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Computes the hash value for the specified region of the input byte array and copies the specified - region of the input byte array to the specified region of the output byte array. - - The input to compute the hash code for. - The offset into the input byte array from which to begin using data. - The number of bytes in the input byte array to use as data. - A copy of the part of the input array used to compute the hash code. - The offset into the output byte array from which to begin writing data. - - The number of bytes written. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the specified region of the specified byte array. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - An array that is a copy of the part of the input that is hashed. - - - uses an invalid value. - -or- - has an invalid length. - - is null. - is out of range. This parameter requires a non-negative number. - The object has already been disposed. - - - - Computes the hash value for the input data. - - The input to compute the hash code for. - - The computed hash code. - - is null. - The object has already been disposed. - - - - MD5 algorithm implementation - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Cryptographic hash function based upon the Merkle–Damgård construction. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Reset the chaining variables to the IV values. - - - - - Rounds 0-15 - - The x. - The y. - The z. - - - - - Rounds 16-31 - - The x. - The y. - The z. - - - - - ounds 32-47 - - The x. - The y. - The z. - - - - - Rounds 48-63 - - The x. - The y. - The z. - - - - - ounds 64-79 - - The x. - The y. - The z. - - - - - Computes the SHA1 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA256 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Gets the input block size. - - - The input block size. - - - - - Gets the output block size. - - - The output block size. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - The SHA-256 Constants (represent the first 32 bits of the fractional parts of the cube roots of the first sixty-four prime numbers) - - - - - Initial hash value 1. - - - - - Initial hash value 2. - - - - - Initial hash value 3. - - - - - Initial hash value 4. - - - - - Initial hash value 5. - - - - - Initial hash value 6. - - - - - Initial hash value 7. - - - - - Initial hash value 8. - - - - - The word buffer. - - - - - Initializes a new instance of the class. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Initializes an implementation of the class. - - - - - Finalizes the hash computation. - - - - - Adjust the byte counts so that byteCount2 represents the upper long (less 3 bits) word of the byte count. - - - - - Computes the SHA384 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Computes the SHA512 hash for input data. - - - - - Initializes a new instance of the class. - - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - Routes data written to the object into the hash algorithm for computing the hash. - - The input to compute the hash code for. - The offset into the byte array from which to begin using data. - The number of bytes in the byte array to use as data. - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - - Gets the size, in bits, of the computed hash code. - - - The size, in bits, of the computed hash code. - - - - - When overridden in a derived class, gets the input block size. - - - The input block size. - - - - - When overridden in a derived class, gets the output block size. - - - The output block size. - - - - - Finalizes the hash computation after the last data is processed by the cryptographic stream object. - - - The computed hash code. - - - - - Initializes an implementation of the class. - - - - diff --git a/packages/System.IO.4.1.0/System.IO.4.1.0.nupkg b/packages/System.IO.4.1.0/System.IO.4.1.0.nupkg deleted file mode 100644 index 1210d81d0dabf7cbda6eaf75ff7e56b2bf37d7fa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 694059 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ǤEv~;bQ#E?h!s+FbIxiSx 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 K@PmH&?f(HTQj2l` diff --git a/packages/System.IO.4.1.0/ThirdPartyNotices.txt b/packages/System.IO.4.1.0/ThirdPartyNotices.txt deleted file mode 100644 index 55cfb208..00000000 --- a/packages/System.IO.4.1.0/ThirdPartyNotices.txt +++ /dev/null @@ -1,31 +0,0 @@ -This Microsoft .NET Library may incorporate components from the projects listed -below. Microsoft licenses these components under the Microsoft .NET Library -software license terms. The original copyright notices and the licenses under -which Microsoft received such components are set forth below for informational -purposes only. Microsoft reserves all rights not expressly granted herein, -whether by implication, estoppel or otherwise. - -1. .NET Core (https://github.com/dotnet/core/) - -.NET Core -Copyright (c) .NET Foundation and Contributors - -The MIT License (MIT) - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file diff --git a/packages/System.IO.4.1.0/dotnet_library_license.txt b/packages/System.IO.4.1.0/dotnet_library_license.txt deleted file mode 100644 index 92b6c443..00000000 --- a/packages/System.IO.4.1.0/dotnet_library_license.txt +++ /dev/null @@ -1,128 +0,0 @@ - -MICROSOFT SOFTWARE LICENSE TERMS - - -MICROSOFT .NET LIBRARY - -These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft - -· updates, - -· supplements, - -· Internet-based services, and - -· support services - -for this software, unless other terms accompany those items. If so, those terms apply. - -BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE. - - -IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW. - -1. INSTALLATION AND USE RIGHTS. - -a. Installation and Use. You may install and use any number of copies of the software to design, develop and test your programs. - -b. Third Party Programs. The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only. - -2. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS. - -a. DISTRIBUTABLE CODE. The software is comprised of Distributable Code. “Distributable Code” is code that you are permitted to distribute in programs you develop if you comply with the terms below. - -i. Right to Use and Distribute. - -· You may copy and distribute the object code form of the software. - -· Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs. - -ii. Distribution Requirements. For any Distributable Code you distribute, you must - -· add significant primary functionality to it in your programs; - -· require distributors and external end users to agree to terms that protect it at least as much as this agreement; - -· display your valid copyright notice on your programs; and - -· indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs. - -iii. Distribution Restrictions. You may not - -· alter any copyright, trademark or patent notice in the Distributable Code; - -· use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; - -· include Distributable Code in malicious, deceptive or unlawful programs; or - -· modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that - -· the code be disclosed or distributed in source code form; or - -· others have the right to modify it. - -3. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not - -· work around any technical limitations in the software; - -· reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation; - -· publish the software for others to copy; - -· rent, lease or lend the software; - -· transfer the software or this agreement to any third party; or - -· use the software for commercial software hosting services. - -4. BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software. - -5. DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes. - -6. EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see www.microsoft.com/exporting. - -7. SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it. - -8. ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services. - -9. APPLICABLE LAW. - -a. United States. If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort. - -b. Outside the United States. If you acquired the software in any other country, the laws of that country apply. - -10. LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so. - -11. DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - -FOR AUSTRALIA – YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS. - -12. LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES. - -This limitation applies to - -· anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and - -· claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law. - -It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages. - -Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French. - -Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français. - -EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues. - -LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices. - -Cette limitation concerne : - -· tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et - -· les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur. - -Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard. - -EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas. - - diff --git a/packages/System.IO.4.1.0/lib/MonoAndroid10/_._ b/packages/System.IO.4.1.0/lib/MonoAndroid10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/MonoTouch10/_._ b/packages/System.IO.4.1.0/lib/MonoTouch10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/net45/_._ b/packages/System.IO.4.1.0/lib/net45/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/net462/System.IO.dll b/packages/System.IO.4.1.0/lib/net462/System.IO.dll deleted file mode 100644 index 42d512c9f72a44680a1753e726221ea9c82a3930..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 22184 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 B6@35z diff --git a/packages/System.IO.4.1.0/lib/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.1.0/lib/portable-net45+win8+wp8+wpa81/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/win8/_._ b/packages/System.IO.4.1.0/lib/win8/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/wp80/_._ b/packages/System.IO.4.1.0/lib/wp80/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/wpa81/_._ b/packages/System.IO.4.1.0/lib/wpa81/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/xamarinios10/_._ b/packages/System.IO.4.1.0/lib/xamarinios10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/xamarinmac20/_._ b/packages/System.IO.4.1.0/lib/xamarinmac20/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/xamarintvos10/_._ b/packages/System.IO.4.1.0/lib/xamarintvos10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/lib/xamarinwatchos10/_._ b/packages/System.IO.4.1.0/lib/xamarinwatchos10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/MonoAndroid10/_._ b/packages/System.IO.4.1.0/ref/MonoAndroid10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/MonoTouch10/_._ b/packages/System.IO.4.1.0/ref/MonoTouch10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/net45/_._ b/packages/System.IO.4.1.0/ref/net45/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/net462/System.IO.dll b/packages/System.IO.4.1.0/ref/net462/System.IO.dll deleted file mode 100644 index 42d512c9f72a44680a1753e726221ea9c82a3930..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 22184 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 B6@35z diff --git a/packages/System.IO.4.1.0/ref/netcore50/System.IO.dll b/packages/System.IO.4.1.0/ref/netcore50/System.IO.dll deleted file mode 100644 index 4bc64f3928aedae16e08170388511348dbf676e2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29864 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�$pQO;0L%zP?$;33|s|xiPHa)JnRw5;{9V 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 Wp1$q6S?`&3-GH>3>Qxc2ZvH - - - System.IO - - - -

Reads primitive data types as binary values in a specific encoding. - 2 - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The input stream. - The stream does not support reading, is null, or is already closed. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The input stream. - The character encoding to use. - The stream does not support reading, is null, or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The input stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support reading, is null, or is already closed. - - or is null. - - - Exposes access to the underlying stream of the . - The underlying stream associated with the BinaryReader. - 2 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Fills the internal buffer with the specified number of bytes read from the stream. - The number of bytes to be read. - The end of the stream is reached before could be read. - An I/O error occurs. - Requested is larger than the internal buffer size. - - - Returns the next available character and does not advance the byte or character position. - The next available character, or -1 if no more characters are available or the stream does not support seeking. - An I/O error occurs. - The current character cannot be decoded into the internal character buffer by using the selected for the stream. - 2 - - - Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - The next character from the input stream, or -1 if no characters are currently available. - An I/O error occurs. - The stream is closed. - 2 - - - Reads the specified number of bytes from the stream, starting from a specified point in the byte array. - The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of bytes to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of characters from the stream, starting from a specified point in the character array. - The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of characters to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads in a 32-bit integer in compressed format. - A 32-bit integer in compressed format. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - The stream is corrupted. - - - Reads a Boolean value from the current stream and advances the current position of the stream by one byte. - true if the byte is nonzero; otherwise, false. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the next byte from the current stream and advances the current position of the stream by one byte. - The next byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. - A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. - The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - An I/O error occurs. - The stream is closed. - - is negative. - 2 - - - Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - A character read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - A surrogate character was read. - 2 - - - Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. - A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. - The number of characters to read. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - The stream is closed. - An I/O error occurs. - - is negative. - 2 - - - Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. - A decimal value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. - An 8-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. - A 2-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. - A 4-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. - An 8-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a signed byte from this stream and advances the current position of the stream by one byte. - A signed byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. - A 4-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. - The string being read. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. - A 2-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. - A 4-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. - An 8-byte unsigned integer read from this stream. - The end of the stream is reached. - An I/O error occurs. - The stream is closed. - 2 - - - Writes primitive types in binary to a stream and supports writing strings in a specific encoding. - 2 - - - Initializes a new instance of the class that writes to a stream. - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The output stream. - The stream does not support writing or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The output stream. - The character encoding to use. - The stream does not support writing or is already closed. - - or is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The output stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support writing or is already closed. - - or is null. - - - Gets the underlying stream of the . - The underlying stream associated with the BinaryWriter. - 1 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Specifies a with no backing store. - 1 - - - Holds the underlying stream. - - - Sets the position within the current stream. - The position with the current stream. - A byte offset relative to . - A field of indicating the reference point from which the new position is to be obtained. - The file pointer was moved to an invalid location. - The value is invalid. - 1 - - - Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. - The Boolean value to write (0 or 1). - An I/O error occurs. - The stream is closed. - 1 - - - Writes an unsigned byte to the current stream and advances the stream position by one byte. - The unsigned byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a byte array to the underlying stream. - A byte array containing the data to write. - An I/O error occurs. - The stream is closed. - - is null. - 1 - - - Writes a region of a byte array to the current stream. - A byte array containing the data to write. - The starting point in at which to begin writing. - The number of bytes to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - The non-surrogate, Unicode character to write. - An I/O error occurs. - The stream is closed. - - is a single surrogate character. - 1 - - - Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - A character array containing the data to write. - - is null. - The stream is closed. - An I/O error occurs. - 1 - - - Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. - A character array containing the data to write. - The starting point in from which to begin writing. - The number of characters to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a decimal value to the current stream and advances the stream position by sixteen bytes. - The decimal value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. - The eight-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. - The two-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. - The four-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. - The eight-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a signed byte to the current stream and advances the stream position by one byte. - The signed byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. - The four-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. - The value to write. - An I/O error occurs. - - is null. - The stream is closed. - 1 - - - Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. - The two-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. - The four-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. - The eight-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a 32-bit integer in a compressed format. - The 32-bit integer to be written. - The end of the stream is reached. - The stream is closed. - The stream is closed. - - - The exception that is thrown when reading is attempted past the end of a stream. - 2 - - - Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. - - - Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - - - Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - The exception that is thrown when a data stream is in an invalid format. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with a specified error message. - The error message that explains the reason for the exception. - - - Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. - The error message that explains the reason for the exception. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class with an expandable capacity initialized to zero. - - - Initializes a new non-resizable instance of the class based on the specified byte array. - The array of unsigned bytes from which to create the current stream. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. - The array of unsigned bytes from which to create this stream. - The setting of the property, which determines whether the stream supports writing. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - - is null. - - or is less than zero. - The buffer length minus is less than . - - - Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. - The array of unsigned bytes from which to create this stream. - The index in at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - - is null. - - or are negative. - The buffer length minus is less than . - - - Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. - - is null. - - or is negative. - The buffer length minus is less than . - - - Initializes a new instance of the class with an expandable capacity initialized as specified. - The initial size of the internal array in bytes. - - is negative. - - - Gets a value indicating whether the current stream supports reading. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports seeking. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 2 - - - Gets or sets the number of bytes allocated for this stream. - The length of the usable portion of the buffer for the stream. - A capacity is set that is negative or less than the current length of the stream. - The current stream is closed. - set is invoked on a stream whose capacity cannot be modified. - 2 - - - Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. - The token to monitor for cancellation requests. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Overrides the method so that no action is performed. - 2 - - - Asynchronously clears all buffers for this stream, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. - The stream has been disposed. - - - Gets the length of the stream in bytes. - The length of the stream in bytes. - The stream is closed. - 2 - - - Gets or sets the current position within the stream. - The current position within the stream. - The position is set to a negative value or a value greater than . - The stream is closed. - 2 - - - Reads a block of bytes from the current stream and writes the data to a buffer. - The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. - When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. - The zero-based byte offset in at which to begin storing data from the current stream. - The maximum number of bytes to read. - - is null. - - or is negative. - - subtracted from the buffer length is less than . - The current stream instance is closed. - 2 - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the current stream. - The byte cast to a , or -1 if the end of the stream has been reached. - The current stream instance is closed. - 2 - - - Sets the position within the current stream to the specified value. - The new position within the stream, calculated by combining the initial reference point and the offset. - The new position within the stream. This is relative to the parameter, and can be positive or negative. - A value of type , which acts as the seek reference point. - Seeking is attempted before the beginning of the stream. - - is greater than . - There is an invalid . -or- caused an arithmetic overflow. - The current stream instance is closed. - 2 - - - Sets the length of the current stream to the specified value. - The value at which to set the length. - The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. - - is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. - 2 - - - Writes the stream contents to a byte array, regardless of the property. - A new byte array. - 2 - - - Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. - true if the conversion was successful; otherwise, false. - The byte array segment from which this stream was created. - - - Writes a block of bytes to the current stream using data read from a buffer. - The buffer to write data from. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The maximum number of bytes to write. - - is null. - The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. - - subtracted from the buffer length is less than . - - or are negative. - An I/O error occurs. - The current stream instance is closed. - 2 - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current stream at the current position. - The byte to write. - The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. - The current stream is closed. - 2 - - - Writes the entire contents of this memory stream to another stream. - The stream to write this memory stream to. - - is null. - The current or target stream is closed. - 2 - - - Specifies the position in a stream to use for seeking. - 2 - - - Specifies the beginning of a stream. - - - Specifies the current position within a stream. - - - Specifies the end of a stream. - - - Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class. - - - When overridden in a derived class, gets a value indicating whether the current stream supports reading. - true if the stream supports reading; otherwise, false. - 1 - - - When overridden in a derived class, gets a value indicating whether the current stream supports seeking. - true if the stream supports seeking; otherwise, false. - 1 - - - Gets a value that determines whether the current stream can time out. - A value that determines whether the current stream can time out. - 2 - - - When overridden in a derived class, gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 1 - - - Reads the bytes from the current stream and writes them to another stream. - The stream to which the contents of the current stream will be copied. - - is null. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - The stream to which the contents of the current stream will be copied. - The size of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Asynchronously reads the bytes from the current stream and writes them to another stream. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - - is null. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - The token to monitor for cancellation requests. The default value is . - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases all resources used by the . - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. - An I/O error occurs. - 2 - - - Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. The default value is . - The stream has been disposed. - - - When overridden in a derived class, gets the length in bytes of the stream. - A long value representing the length of the stream in bytes. - A class derived from Stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - A Stream with no backing store. - 1 - - - When overridden in a derived class, gets or sets the position within the current stream. - The current position within the stream. - An I/O error occurs. - The stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - The sum of and is larger than the buffer length. - - is null. - - or is negative. - An I/O error occurs. - The stream does not support reading. - Methods were called after the stream was closed. - 1 - - - Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. - The unsigned byte cast to an Int32, or -1 if at the end of the stream. - The stream does not support reading. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. - A value, in miliseconds, that determines how long the stream will attempt to read before timing out. - The method always throws an . - 2 - - - When overridden in a derived class, sets the position within the current stream. - The new position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - An I/O error occurs. - The stream does not support seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - An I/O error occurs. - The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 2 - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - The sum of  and  is greater than the buffer length. - - is null. - - or  is negative. - An I/O error occured, such as the specified file cannot be found. - The stream does not support writing. - - was called after the stream was closed. - 1 - - - Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current position in the stream and advances the position within the stream by one byte. - The byte to write to the stream. - An I/O error occurs. - The stream does not support writing, or the stream is already closed. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. - A value, in miliseconds, that determines how long the stream will attempt to write before timing out. - The method always throws an . - 2 - - - Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream. - The stream to be read. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. - The stream to be read. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding. - The stream to be read. - The character encoding to use. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - The minimum buffer size. - The stream does not support reading. - - or is null. - - is less than or equal to zero. - - - Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. - The stream to read. - The character encoding to use. - true to look for byte order marks at the beginning of the file; otherwise, false. - The minimum buffer size. - true to leave the stream open after the object is disposed; otherwise, false. - - - Returns the underlying stream. - The underlying stream. - 2 - - - Gets the current character encoding that the current object is using. - The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. - 2 - - - Clears the internal buffer. - 2 - - - Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets a value that indicates whether the current stream position is at the end of the stream. - true if the current stream position is at the end of the stream; otherwise false. - The underlying stream has been disposed. - 1 - - - A object around an empty stream. - 1 - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. - An I/O error occurs. - 1 - - - Reads the next character from the input stream and advances the character position by one character. - The next character from the input stream represented as an object, or -1 if no more characters are available. - An I/O error occurs. - 1 - - - Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. - The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The index of at which to begin writing. - The maximum number of characters to read. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs, such as the stream is closed. - 1 - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurred. - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current stream and returns the data as a string. - The next line from the input stream, or null if the end of the input stream is reached. - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads a line of characters asynchronously from the current stream and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the stream. - The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. - The number of characters is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. - The stream to write to. - - is not writable. - - is null. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. - The stream to write to. - The character encoding to use. - - or is null. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - - or is null. - - is negative. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - true to leave the stream open after the object is disposed; otherwise, false. - - or is null. - - is negative. - - is not writable. - - - Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . - true to force to flush its buffer; otherwise, false. - 1 - - - Gets the underlying stream that interfaces with a backing store. - The stream this StreamWriter is writing to. - 2 - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - The current encoding does not support displaying half of a Unicode surrogate pair. - - - Gets the in which the output is written. - The specified in the constructor for the current instance, or if an encoding was not specified. - 2 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. - The current writer is closed. - An I/O error has occurred. - The current encoding does not support displaying half of a Unicode surrogate pair. - 1 - - - Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Provides a StreamWriter with no backing store that can be written to, but not read from. - 1 - - - Writes a character to the stream. - The character to write to the stream. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a character array to the stream. - A character array containing the data to write. If is null, nothing is written. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a subarray of characters to the stream. - A character array that contains the data to write. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The buffer length minus is less than . - - or is negative. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a string to the stream. - The string to write to the stream. If is null, nothing is written. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - An I/O error occurs. - 1 - - - Writes a character to the stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the stream asynchronously. - A task that represents the asynchronous write operation. - A character array that contains the data to write. - The character position in the buffer at which to begin reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string to the stream asynchronously. - A task that represents the asynchronous write operation. - The string to write to the stream. If is null, nothing is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Implements a that reads from a string. - 2 - - - Initializes a new instance of the class that reads from the specified string. - The string to which the should be initialized. - The parameter is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. - The current reader is closed. - 2 - - - Reads the next character from the input string and advances the character position by one character. - The next character from the underlying string, or -1 if no more characters are available. - The current reader is closed. - 2 - - - Reads a block of characters from the input string and advances the character position by . - The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The starting index in the buffer. - The number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The current reader is closed. - 2 - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current string and returns the data as a string. - The next line from the current string, or null if the end of the string is reached. - The current reader is closed. - There is insufficient memory to allocate a buffer for the returned string. - 2 - - - Reads a line of characters asynchronously from the current string and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the string and returns them as a single string. - The content from the current position to the end of the underlying string. - There is insufficient memory to allocate a buffer for the returned string. - The current reader is closed. - 2 - - - Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. - The number of characters is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing information to a string. The information is stored in an underlying . - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format control. - An object that controls formatting. - - - Initializes a new instance of the class that writes to the specified . - The StringBuilder to write to. - - is null. - - - Initializes a new instance of the class that writes to the specified and has the specified format provider. - The StringBuilder to write to. - An object that controls formatting. - - is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets the in which the output is written. - The Encoding in which the output is written. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - - - Returns the underlying . - The underlying StringBuilder. - 2 - - - Returns a string containing the characters written to the current StringWriter so far. - The string containing the characters written to the current StringWriter. - 2 - - - Writes a character to the string. - The character to write. - The writer is closed. - 2 - - - Writes a subarray of characters to the string. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - - or is negative. - ( + )> . Length. - The writer is closed. - 2 - - - Writes a string to the current string. - The string to write. - The writer is closed. - 2 - - - Writes a character to the string asynchronously. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the string asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string to the current string asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the current string. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Represents a reader that can read a sequential series of characters. - 2 - - - Initializes a new instance of the class. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Provides a TextReader with no data to read from. - 1 - - - Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. - An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. - The is closed. - An I/O error occurs. - 1 - - - Reads the next character from the text reader and advances the character position by one character. - The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 2 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the text reader and returns the data as a string. - The next line from the reader, or null if all characters have been read. - An I/O error occurs. - There is insufficient memory to allocate a buffer for the returned string. - The is closed. - The number of characters in the next line is larger than - 1 - - - Reads a line of characters asynchronously and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. - The number of characters in the next line is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the text reader and returns them as one string. - A string that contains all characters from the current position to the end of the text reader. - An I/O error occurs. - The is closed. - There is insufficient memory to allocate a buffer for the returned string. - The number of characters in the next line is larger than - 1 - - - Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. - The number of characters is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Represents a writer that can write a sequential series of characters. This class is abstract. - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format provider. - An object that controls formatting. - - - Stores the newline characters used for this TextWriter. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, returns the character encoding in which the output is written. - The character encoding in which the output is written. - 1 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The text writer is disposed. - The writer is currently in use by a previous write operation. - - - Gets an object that controls formatting. - An object for a specific culture, or the formatting of the current culture if no other culture is specified. - 2 - - - Gets or sets the line terminator string used by the current TextWriter. - The line terminator string for the current TextWriter. - 2 - - - Provides a TextWriter with no backing store that can be written to, but not read from. - 1 - - - Writes the text representation of a Boolean value to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a character array to the text string or stream. - The character array to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters to the text string or stream. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte floating-point value to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object to the text string or stream by calling the ToString method on that object. - The object to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string to the text string or stream. - The string to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - - or is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character array to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If is null, nothing is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a line terminator to the text string or stream. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character followed by a line terminator to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes an array of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The character position in at which to start reading data. - The maximum number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value followed by a line terminator to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. - The object to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string followed by a line terminator to the text string or stream. - The string to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - A string or object is passed in as null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes an array of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If the character array is null, only the line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml deleted file mode 100644 index 07b2661f..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/de/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. - 2 - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. - Der Eingabestream. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - oder ist null. - - - Gewährt Zugriff auf den zugrunde liegenden Stream von . - Der BinaryReader zugeordnete, zugrunde liegende Stream. - 2 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. - Die Anzahl der zu lesenden Bytes. - Das Ende des Streams ist erreicht, bevor gelesen werden konnte. - E/A-Fehler. - Die angeforderten überschreiten die interne Puffergröße. - - - Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. - Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. - 2 - - - Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. - Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Bytes. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 32-Bit-Ganzzahl in komprimiertem Format. - Eine 32-Bit-Ganzzahl in komprimiertem Format. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Der Datenstrom ist beschädigt. - - - Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - true, wenn das Byte ungleich 0 (null) ist, andernfalls false. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - Das nächste aus dem aktuellen Stream gelesene Byte. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. - Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - E/A-Fehler. - Der Stream ist geschlossen. - - ist negativ. - 2 - - - Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein aus dem aktuellen Stream gelesenes Zeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Ein Ersatzzeichenzeichen wurde gelesen. - 2 - - - Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Zeichen. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - Der Stream ist geschlossen. - E/A-Fehler. - - ist negativ. - 2 - - - Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. - Ein aus dem aktuellen Stream gelesener Dezimalwert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. - Die gelesene Zeichenfolge. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. - Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. - Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. - 2 - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. - - - Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. - Der Ausgabestream. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Ruft den zugrunde liegenden Stream von ab. - Der BinaryWriter zugeordnete, zugrunde liegende Stream. - 1 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Gibt eine -Klasse ohne Sicherungsspeicher an. - 1 - - - Enthält den zugrunde liegenden Stream. - - - Legt die Position im aktuellen Stream fest. - Die Position im aktuellen Stream. - Ein Byteoffset im Verhältnis zu . - Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. - Der Dateizeiger wurde an eine ungültige Position verschoben. - Der -Wert ist ungültig. - 1 - - - Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. - Der zu schreibende Boolean-Wert (0 (null) oder 1). - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Bytearray in den zugrunde liegenden Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - E/A-Fehler. - Der Stream ist geschlossen. - - ist null. - 1 - - - Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Bytes. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). - E/A-Fehler. - Der Stream ist geschlossen. - - ist ein einzelnes Ersatzzeichen. - 1 - - - Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - - ist null. - Der Stream ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. - Der zu schreibende Dezimalwert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Der zu schreibende 8-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Der zu schreibende 4-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. - Der zu schreibende Wert. - E/A-Fehler. - - ist null. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. - Die zu schreibende 32-Bit-Ganzzahl. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - Der Stream ist geschlossen. - - - Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. - 2 - - - Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. - - - Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - - - Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. - - ist null. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - - Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - - ist null. - - oder ist kleiner als 0. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , bei dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. - Die Anfangsgröße des internen Arrays in Bytes. - - ist negativ. - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 2 - - - Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. - Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. - Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. - Der aktuelle Stream ist geschlossen. - set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. - 2 - - - Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. - Das Token zum überwachen von Abbruchanforderungen . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen . - Der Stream wurde freigegeben. - - - Ruft die Länge des Streams in Bytes ab. - Die Länge des Streams in Bytes. - Der Stream ist geschlossen. - 2 - - - Ruft die aktuelle Position im Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. - Der Stream ist geschlossen. - 2 - - - Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. - Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. - Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - - subtrahiert von der Pufferlänge ist kleiner als . - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem aktuellen Stream. - Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Position im aktuellen Stream auf den angegebenen Wert fest. - Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. - Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. - Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. - Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. - - ist größer als . - Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. - Der Wert, auf den die Länge festgelegt werden soll. - Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. - - ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. - 2 - - - Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. - Ein neues Bytearray. - 2 - - - Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. - true, wenn die Konvertierung erfolgreich war, andernfalls false. - Das Bytearraysegment, aus dem der Stream erstellt wurde. - - - Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. - - subtrahiert von der Pufferlänge ist kleiner als . - - oder ist negativ. - E/A-Fehler. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuelle Position im aktuellen Stream. - Das zu schreibende Byte. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. - Der aktuelle Stream ist geschlossen. - 2 - - - Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. - Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. - - ist null. - Der aktuelle Stream oder der Zielstream ist geschlossen. - 2 - - - Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. - 2 - - - Gibt den Anfang eines Streams an. - - - Gibt die aktuelle Position innerhalb eines Streams an. - - - Gibt das Ende eines Streams an. - - - Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. - 1 - - - Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - 2 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 1 - - - Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt alle vom verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - E/A-Fehler. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - Der Stream wurde freigegeben. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. - Ein Long-Wert, der die Länge des Streams in Bytes darstellt. - Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Ein Stream ohne Sicherungsspeicher. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. - Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. - Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. - Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. - Die Summe aus und ist größer als die Pufferlänge. - - ist null. - - oder ist negativ. - E/A-Fehler. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. - Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. - Die neue Position innerhalb des aktuellen Streams. - Ein Byteoffset relativ zum -Parameter. - Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. - Die gewünschte Länge des aktuellen Streams in Bytes. - E/A-Fehler. - Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. - Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. - Die Summe der  und  ist größer als die Länge des Puffers. - - ist null. - - oder  ist negativ. - E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. - Der Stream unterstützt das Schreiben nicht. - - wurde aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das Byte, das in den Stream geschrieben werden soll. - E/A-Fehler. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. - Der zu lesende Stream. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - Die Mindestgröße des Puffers. - Lesevorgänge werden vom Stream nicht unterstützt. - - oder ist null. - - ist kleiner oder gleich 0 (null). - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. - Die Mindestgröße des Puffers. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - - Gibt den zugrunde liegenden Stream zurück. - Der zugrunde liegende Stream. - 2 - - - Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. - Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. - 2 - - - Löscht den internen Puffer. - 2 - - - Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. - true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. - Der zugrunde liegende Stream wurde verworfen. - 1 - - - Ein -Objekt um einen leeren Stream. - 1 - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. - E/A-Fehler. - 1 - - - Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. - Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Index von , bei dem mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - Ein E/A-Fehler ist aufgetreten. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. - Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. - Die Anzahl der Zeichen ist niedriger als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - - ist schreibgeschützt. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - - oder ist null. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. - true, um zum Entleeren des Puffers zu zwingen, andernfalls false. - 1 - - - Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. - Der Stream, in den dieser StreamWriter schreibt. - 2 - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. - 2 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. - Der aktuelle Writer wird geschlossen. - Ein E/A-Fehler ist aufgetreten. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - 1 - - - Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt ein Zeichen in den Stream. - Das in den Stream zu schreibende Zeichen. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Zeichenarray in den Stream. - Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Teilarray von Zeichen in den Stream. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt eine Zeichenfolge in den Stream. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Implementiert einen , der aus einer Zeichenfolge liest. - 2 - - - Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. - Die Zeichenfolge, mit der der initialisiert werden soll. - Der -Parameter ist null. - - - Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Anfangsindex im Puffer. - Die Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. - Der aktuelle Reader ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - 2 - - - Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. - Die Anzahl der Zeichen ist niedriger als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. - Ein -Objekt zum Steuern der Formatierung. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . - Der StringBuilder, in den geschrieben werden soll. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. - Der StringBuilder, in den geschrieben werden soll. - Ein -Objekt zum Steuern der Formatierung. - - ist null. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die Encoding, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - - - Gibt den zugrunde liegenden zurück. - Der zugrunde liegende StringBuilder. - 2 - - - Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - 2 - - - Schreibt ein Zeichen in die Zeichenfolge. - Das zu schreibende Zeichen. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Teilarray von Zeichen in die Zeichenfolge. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - - oder ist negativ. - ( + )> .Length. - Der Writer ist geschlossen. - 2 - - - Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. - Die zu schreibende Zeichenfolge. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Stellt einen TextReader ohne zu lesende Daten bereit. - 1 - - - Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. - Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 2 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. - E/A-Fehler. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der ist geschlossen. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. - E/A-Fehler. - Der ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. - Die Anzahl der Zeichen ist niedriger als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. - Ein -Objekt zum Steuern der Formatierung. - - - Speichert die für diesen TextWriter verwendeten Zeilenendemarken. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. - Die Zeichencodierung, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Textwriter wird freigegeben. - Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Ruft ein Objekt zum Steuern der Formatierung ab. - Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. - 2 - - - Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. - Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. - 2 - - - Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichenarray. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. - Das zu schreibende Objekt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - - oder ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - Eine Zeichenfolge oder ein Objekt wird als null übergeben. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml deleted file mode 100644 index 0b2c206b..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/es/System.IO.xml +++ /dev/null @@ -1,2090 +0,0 @@ - - - - System.IO - - - - Lee tipos de datos primitivos como valores binarios en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. - La secuencia de entrada. - La secuencia no admite la lectura, es null, o ya está cerrada. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de o es null. - - - Expone el acceso a la secuencia subyacente de . - Secuencia subyacente asociada a BinaryReader. - 2 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. - Número de bytes que se va a leer. - Se llega al final de la secuencia antes de se ha podido leer. - Se produce un error de E/S. - Solicitado es mayor que el tamaño del búfer interno. - - - Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. - Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. - 2 - - - Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. - Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. - Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de bytes que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. - Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de caracteres que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero de 32 bits en formato comprimido. - Entero de 32 bits en formato comprimido. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - La secuencia está dañada. - - - Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Es true si el byte es distinto de cero; en caso contrario, es false. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Siguiente byte que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. - Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. - Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - Se produce un error de E/S. - La secuencia está cerrada. - - es negativo. - 2 - - - Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. - Carácter que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - Se ha leído un carácter suplente. - 2 - - - Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. - Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. - Número de caracteres que se va a leer. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - La secuencia está cerrada. - Se produce un error de E/S. - - es negativo. - 2 - - - Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. - Valor decimal que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. - Valor de punto flotante de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. - Entero con signo de 2 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Entero con signo de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. - Entero con signo de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. - Byte con signo que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Valor de punto flotante de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. - Cadena que se lee. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. - Entero sin signo de 2 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. - Entero sin signo de 4 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. - Entero sin signo de 8 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase que escribe en una secuencia. - - - Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. - Flujo de salida. - La secuencia no admite escritura o ya se encuentra cerrada. - - es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - Flujo de salida. - Codificación de caracteres que se utilizará. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. - Flujo de salida. - Codificación de caracteres que se utilizará. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Obtiene la secuencia subyacente del objeto . - Flujo subyacente asociado a BinaryWriter. - 1 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Especifica un objeto sin memoria auxiliar. - 1 - - - Contiene la secuencia subyacente. - - - Establece la posición en la secuencia actual. - Posición con la secuencia actual. - Desplazamiento de bytes relacionado con . - Un campo de que indica el punto de referencia del que se obtiene la nueva posición. - El puntero de archivo se ha movido a una posición no válida. - El valor de no es válido. - 1 - - - Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. - Valor Boolean que se va a escribir (0 ó 1). - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte sin signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una matriz de bytes en la secuencia subyacente. - Matriz de bytes que contiene los datos que se van a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es null. - 1 - - - Escribe una región de una matriz de bytes en la secuencia actual. - Matriz de bytes que contiene los datos que se van a escribir. - Punto inicial de donde comenzará la escritura. - Número de bytes que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. - El carácter Unicode no suplente que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es un carácter suplente único. - 1 - - - Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - - es null. - La secuencia está cerrada. - Se produce un error de E/S. - 1 - - - Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Punto inicial de donde se empieza a leer. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. - Valor decimal que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Valor de punto flotante de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero con signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero con signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero con signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte con signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Valor de punto flotante de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. - Valor que se va a escribir. - Se produce un error de E/S. - - es null. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero sin signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero sin signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero sin signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero de 32 bits en formato comprimido. - Entero de 32 bits que se va a escribir. - Se llega al final de la secuencia. - La secuencia está cerrada. - La secuencia está cerrada. - - - Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. - 2 - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - - - Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Excepción que se inicia cuando el formato de un flujo de datos no es válido. - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el mensaje de error especificado. - Mensaje de error que explica la razón de la excepción. - - - Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. - Mensaje de error que explica la razón de la excepción. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. - - - Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. - Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - El valor de es null. - - o es menor que cero. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - o son negativos. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. - El valor de es null. - - o es negativo. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. - Tamaño inicial de la matriz interna en bytes. - - es negativo. - - - Obtiene un valor que indica si la secuencia actual admite lectura. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite búsquedas. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 2 - - - Obtiene o establece el número de bytes asignados a esta secuencia. - Longitud de la parte utilizable del búfer para la secuencia. - Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. - La secuencia actual está cerrada. - set se invoca en una secuencia cuya capacidad no se puede modificar. - 2 - - - Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero. - Token para supervisar solicitudes de cancelación. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Reemplaza el método de modo que no se realice ninguna acción. - 2 - - - De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación. - Se ha eliminado la secuencia. - - - Obtiene la longitud de la secuencia en bytes. - Longitud de la secuencia en bytes. - La secuencia está cerrada. - 2 - - - Obtiene o establece la posición actual dentro de la secuencia. - Posición actual dentro de la secuencia. - La posición se establece en un valor negativo o un valor mayor que . - La secuencia está cerrada. - 2 - - - Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. - Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. - Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. - Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - - resta de la longitud del búfer es menor que . - La instancia de la secuencia actual está cerrada. - 2 - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia actual. - El byte convertido en un o -1 si se llega al final de la secuencia. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la posición dentro de la secuencia actual en el valor especificado. - Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. - Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. - Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. - Se ha intentado realizar una búsqueda antes del inicio de la secuencia. - - es mayor que . - Hay un no válido . o bien se produjo un desbordamiento aritmético. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la longitud de la secuencia actual en el valor especificado. - Valor en el que establecer la longitud. - La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. - - es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. - 2 - - - Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . - Nueva matriz de bytes. - 2 - - - Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. - Es true si la conversión se realiza correctamente; en caso contrario, es false. - El segmento de matriz de bytes desde el que se creó esta secuencia. - - - Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número máximo de bytes que se pueden escribir. - El valor de es null. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. - - resta de la longitud del búfer es menor que . - - o son negativos. - Se produce un error de E/S. - La instancia de la secuencia actual está cerrada. - 2 - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte en la posición actual de la secuencia actual. - Byte que se va a escribir. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. - La secuencia actual está cerrada. - 2 - - - Escribe el contenido completo de esta secuencia de memoria en otra secuencia. - Secuencia en la que se va a escribir esta secuencia de memoria. - El valor de es null. - La secuencia actual o de destino está cerrada. - 2 - - - Especifica la posición usada para buscar en una secuencia. - 2 - - - Especifica el comienzo de una secuencia. - - - Especifica lo posición actual dentro de la secuencia. - - - Especifica el final de una secuencia. - - - Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase . - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. - true si la secuencia admite lectura; en caso contrario, false. - 1 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. - true si la secuencia admite búsquedas; en caso contrario, false. - 1 - - - Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - 2 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 1 - - - Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera todos los recursos usados por . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Se produce un error de E/S. - 2 - - - Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - Se ha eliminado la secuencia. - - - Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. - Un valor Long que representa la longitud de la secuencia en bytes. - Una clase derivada de Stream no admite la búsqueda. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Stream sin memoria auxiliar. - 1 - - - Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. - Posición actual dentro de la secuencia. - Se produce un error de E/S. - La secuencia no admite búsquedas. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. - Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. - Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. - Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. - Número máximo de bytes que se deben leer de la secuencia actual. - La suma de y es mayor que la longitud del búfer. - El valor de es null. - - o es negativo. - Se produce un error de E/S. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. - Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. - La nueva posición dentro de la secuencia actual. - Desplazamiento de bytes relacionado con el parámetro . - Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. - Se produce un error de E/S. - La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. - Longitud deseada de la secuencia actual, en bytes. - Se produce un error de E/S. - La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. - Matriz de bytes.Este método copia bytes desde al flujo actual. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número de bytes que se deben escribir en la secuencia actual. - La suma de  y  es mayor que la longitud del búfer. - - es null. - - o  es negativo. - Se produjo un error de E/S, como no se puede encontrar el archivo especificado. - La secuencia no es compatible con la escritura. - - se llama después de cerrar la secuencia. - 1 - - - Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. - Byte que se debe escribir en la secuencia. - Se produce un error de E/S. - La secuencia no admite escritura o ya se encuentra cerrada. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 1 - - - Inicializa una nueva instancia de la clase para el flujo especificado. - Secuencia que se va a leer. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - Tamaño mínimo de búfer. - La secuencia no admite lectura. - El valor de o es null. - - es menor o igual que cero. - - - Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. - Tamaño mínimo de búfer. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - - - Devuelve la secuencia subyacente. - Secuencia subyacente. - 2 - - - Obtiene la codificación de caracteres que actualmente utiliza este objeto . - Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . - 2 - - - Borra el búfer interno. - 2 - - - Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene un valor que indica si la actual posición está al final de la secuencia. - Es true si la actual posición está al final de la secuencia; en caso contrario, es false. - Se ha eliminado la secuencia subyacente. - 1 - - - Objeto en torno a una secuencia vacía. - 1 - - - Devuelve el siguiente carácter disponible pero no lo consume. - Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. - El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. - Se produce un error de E/S. - 1 - - - Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. - Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Índice de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - La longitud del búfer menos es menor que . - El valor de es null. - - o es negativo. - Se produce un error de E/S, como el cierre de la secuencia. - 1 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - - o es negativo. - El se cierra. - Error de E/S. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. - El número de caracteres en la siguiente línea es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la secuencia. - Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. - El número de caracteres es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. - 1 - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - No se puede escribir en . - - is null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - - o es null. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . - Es true para que vacíe su búfer; en caso contrario, es false. - 1 - - - Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. - Secuencia en la que escribe este StreamWriter. - 2 - - - Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. - truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - - - Obtiene el donde se escribe el resultado. - - especificado en el constructor para la instancia actual o si no se ha especificado una codificación. - 2 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. - El sistema de escritura actual está cerrado. - Se produjo un error de E/S. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - 1 - - - Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe un carácter en la secuencia. - Carácter que se va a escribir en la secuencia. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una matriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una submatriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una cadena en la secuencia. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comienza la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Implementa que lee en una cadena. - 2 - - - Inicializa una nueva instancia de la clase que lee en la cadena especificada. - Cadena en la que debe inicializarse. - El parámetro es null. - - - Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Devuelve el siguiente carácter disponible pero no lo consume. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - El sistema de lectura actual está cerrado. - 2 - - - Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. - Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. - El sistema de lectura actual está cerrado. - 2 - - - Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . - Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Índice inicial del búfer. - Número de caracteres que se va a leer. - - es null. - La longitud del búfer menos es menor que . - - o son negativos. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. - El sistema de lectura actual está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - 2 - - - Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Contenido desde la posición actual hasta el final de la cadena subyacente. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. - El número de caracteres es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir información en una cadena.La información se almacena en el subyacente. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Inicializa una nueva instancia de la clase que escribe en el especificado. - Objeto StringBuilder en el que se va a escribir. - - es null. - - - Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. - Objeto StringBuilder en el que se va a escribir. - Objeto que controla las operaciones de formato. - - es null. - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene el donde se escribe el resultado. - Encoding donde se escribe el resultado. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - - - Devuelve el subyacente. - Objeto StringBuilder subyacente. - 2 - - - Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. - Cadena que contiene los caracteres escritos en el StringWriter actual. - 2 - - - Escribe un carácter en la cadena. - Carácter que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe una submatriz de caracteres en la cadena. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - - o son negativos. - ( + ) > .Length. - El sistema de escritura está cerrado. - 2 - - - Escribe una cadena en la cadena actual. - Cadena que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe un carácter en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena actual de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Representa un lector que puede leer una serie secuencial de caracteres. - 2 - - - Inicializa una nueva instancia de la clase . - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. - - - Proporciona un TextReader sin datos del que leer. - 1 - - - Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. - Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. - Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 2 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. - Línea siguiente del lector o null si se han leído todos los caracteres. - Se produce un error de E/S. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El objeto está cerrado. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. - Se produce un error de E/S. - El objeto está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. - El número de caracteres es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Almacena los caracteres de nueva línea usados para el TextWriter. - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. - Codificación de caracteres donde se escriben los resultados. - 1 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se desecha el sistema de escritura de texto. - El sistema de escritura está actualmente en uso por una operación de escritura anterior. - - - Obtiene un objeto que controla las operaciones de formato. - Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. - 2 - - - Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. - Cadena de terminador de línea para el TextWriter actual. - 2 - - - Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. - Objeto que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena en la cadena o secuencia de texto. - Cadena que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - El valor de o es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea en la cadena o secuencia. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - Posición del carácter en donde comenzar a leer datos. - Número máximo de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. - Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. - Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - Una cadena u objeto se pasa como null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml deleted file mode 100644 index 30dc29ab..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/fr/System.IO.xml +++ /dev/null @@ -1,2201 +0,0 @@ - - - - System.IO - - - - Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux d'entrée. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - - Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. - Flux d'entrée. - Encodage des caractères à utiliser. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux d'entrée. - Encodage des caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - ou a la valeur null. - - - Expose l'accès au flux sous-jacent de l'élément . - Flux sous-jacent associé à l'élément BinaryReader. - 2 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. - Nombre d'octets à lire. - La fin du flux est atteinte avant que n'ait pu être lu. - Une erreur d'E/S se produit. - - demandé est plus grand que la taille de la mémoire tampon interne. - - - Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. - Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. - 2 - - - Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. - Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre d'octets à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. - Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier 32 bits au format compressé. - Entier 32 bits au format compressé. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Le flux est endommagé. - - - Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. - true si l'octet est différent de zéro ; sinon, false. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. - Octet suivant lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. - Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. - Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Une erreur d'E/S se produit. - Le flux est fermé. - - est négatif. - 2 - - - Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. - Caractère lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Un caractère de substitution a été lu. - 2 - - - Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. - Nombre de caractères à lire. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Le flux est fermé. - Une erreur d'E/S se produit. - - est négatif. - 2 - - - Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. - Valeur décimale lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Valeur à virgule flottante de 8 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. - Entier signé de 2 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Entier signé de 4 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Entier signé de 8 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. - Octet signé lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Valeur à virgule flottante de 4 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. - Chaîne en cours de lecture. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. - Entier non signé de 2 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. - Entier non signé de 4 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. - Entier non signé de 8 octets lu dans ce flux. - La fin du flux est atteinte. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe qui écrit dans un flux. - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux de sortie. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. - Flux de sortie. - Encodage de caractères à utiliser. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux de sortie. - Encodage de caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Obtient le flux sous-jacent de . - Flux sous-jacent associé à BinaryWriter. - 1 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - 1 - - - Spécifie sans magasin de sauvegarde. - 1 - - - Contient le flux sous-jacent. - - - Définit la position dans le flux actuel. - Position dans le flux actuel. - Offset d'octet par rapport à . - Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. - Le pointeur de fichier a été déplacé vers un emplacement non valide. - La valeur n'est pas valide. - 1 - - - Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. - Valeur Boolean à écrire (0 ou 1). - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. - Octet non signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un tableau d'octets dans le flux sous-jacent. - Tableau d'octets contenant les données à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - a la valeur null. - 1 - - - Écrit une zone d'un tableau d'octets dans le flux actuel. - Tableau d'octets contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre d'octets à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Caractère Unicode de non-substitution à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - est un caractère de substitution unique. - 1 - - - Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Tableau de caractères contenant les données à écrire. - - a la valeur null. - Le flux est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. - Tableau de caractères contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. - Valeur décimale à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Valeur à virgule flottante de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. - Octet signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Valeur à virgule flottante de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. - Valeur à écrire. - Une erreur d'E/S se produit. - - a la valeur null. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier non signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier non signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier non signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un nombre entier 32 bits dans un format compressé. - Entier 32 bits à écrire. - La fin du flux est atteinte. - Le flux est fermé. - Le flux est fermé. - - - Exception levée en cas de tentative de lecture au-delà de la fin du flux. - 2 - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Exception qui est levée lorsque le format d'un flux de données n'est pas valide. - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. - Message d'erreur indiquant la raison de l'exception. - - - Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. - Message d'erreur indiquant la raison de l'exception. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. - Tableau d'octets non signés à partir duquel créer le flux actuel. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - - a la valeur null. - - ou est inférieur à zéro. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. - Taille initiale du tableau interne, en octets. - - est négatif. - - - Obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 2 - - - Obtient ou définit le nombre d'octets alloués pour ce flux. - Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. - La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. - Le flux actuel est fermé. - set est appelé sur un flux dont la capacité ne peut pas être modifiée. - 2 - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. - Jeton pour surveiller les demandes d'annulation. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplace la méthode afin qu'aucune action ne soit effectuée. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation. - Le flux a été supprimé. - - - Obtient la longueur du flux en octets. - Longueur du flux en octets. - Le flux est fermé. - 2 - - - Obtient ou définit la position actuelle dans le flux. - Position actuelle dans le flux. - La position correspond à une valeur négative ou à une valeur supérieure à . - Le flux est fermé. - 2 - - - Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. - Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. - Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - - soustrait à la longueur de la mémoire tampon est inférieur à . - L'instance du flux actuel est fermée. - 2 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet dans le flux actuel. - Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. - L'instance du flux actuel est fermée. - 2 - - - Définit la position dans le flux actuel à la valeur spécifiée. - Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. - Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. - Valeur de type , qui sert de point de référence à la recherche. - Tentative de recherche avant le début du flux. - - est supérieur à . - Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. - L'instance du flux actuel est fermée. - 2 - - - Définit la longueur du flux actuel à la valeur spécifiée. - Valeur à laquelle définir la longueur. - Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. - - est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. - 2 - - - Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . - Nouveau tableau d'octets. - 2 - - - Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. - true si la conversion a réussi ; sinon, false. - Segment de tableau d'octets à partir duquel ce flux a été créé. - - - Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre maximal d'octets à écrire. - - a la valeur null. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. - - soustrait à la longueur de la mémoire tampon est inférieur à . - - ou est négatif. - Une erreur d'E/S se produit. - L'instance du flux actuel est fermée. - 2 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux actuel. - Octet à écrire. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. - Le flux actuel est fermé. - 2 - - - Écrit le contenu complet de ce flux de mémoire dans un autre flux. - Flux dans lequel écrire ce flux de mémoire. - - a la valeur null. - Le flux en cours ou le flux cible est fermé. - 2 - - - Spécifie la position au sein d'un flux à utiliser pour la recherche. - 2 - - - Spécifie le début d'un flux. - - - Spécifie la position actuelle au sein d'un flux. - - - Spécifie la fin d'un flux. - - - Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe . - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux prend en charge la lecture ; sinon, false. - 1 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux prend en charge la recherche ; sinon, false. - 1 - - - Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - 2 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 1 - - - Lit les octets du flux actuel et les écrit dans un autre flux. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Flux vers lequel le contenu du flux actuel sera copié. - Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. - Une erreur d'E/S se produit. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - Le flux a été supprimé. - - - En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. - Valeur de type long représentant la longueur du flux en octets. - Une classe dérivée de Stream ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Élément Stream sans magasin de stockage. - 1 - - - En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. - Position actuelle dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. - Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. - Nombre maximal d'octets à lire dans le flux actuel. - La somme de et de est supérieure à la longueur de la mémoire tampon. - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. - Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. - Nouvelle position dans le flux actuel. - Offset d'octet par rapport au paramètre . - Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. - Longueur souhaitée du flux actuel en octets. - Une erreur d'E/S se produit. - Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. - Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre d'octets à écrire dans le flux actuel. - La somme des  et  est supérieure à la longueur du tampon. - - est null. - - ou  est un nombre négatif. - Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. - Le flux ne prend pas en charge l'écriture. - - a été appelée une fois que le flux a été fermé. - 1 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. - Octet à écrire dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié. - Flux à lire. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. - Flux à lire. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. - Flux à lire. - Encodage des caractères à utiliser. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - Taille minimale de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - - ou a la valeur null. - - est inférieur ou égal à zéro. - - - Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux à lire. - Encodage des caractères à utiliser. - true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. - Taille minimale de la mémoire tampon. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - - Retourne le flux sous-jacent. - Flux sous-jacent. - 2 - - - Obtient l'encodage de caractères actuel utilisé par l'objet actuel. - Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . - 2 - - - Efface la mémoire tampon interne. - 2 - - - Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. - true si la position actuelle dans le flux est à la fin du flux ; sinon, false. - Le flux sous-jacent a été supprimé. - 1 - - - Objet autour d'un flux vide. - 1 - - - Retourne le caractère disponible suivant, mais ne le consomme pas. - Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. - Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. - Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Index de auquel commencer l'écriture. - Nombre maximal de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S, telle que la fermeture du flux, se produit. - 1 - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S s'est produite. - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. - Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du flux. - Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. - Le nombre de caractères est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. - Le flux dans lequel écrire. - - n'est pas accessible en écriture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - - ou est null. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . - true pour forcer à vider sa mémoire tampon ; sinon, false. - 1 - - - Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. - Flux dans lequel ce StreamWriter écrit. - 2 - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - - - Obtient le dans lequel la sortie est écrite. - - spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. - 2 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. - Le writer actuel est fermé. - Une erreur d'E/S s'est produite. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - 1 - - - Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. - 1 - - - Écrit un caractère dans le flux. - Caractère à écrire dans le flux. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un sous-tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit une chaîne dans le flux. - Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire où commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire dans le flux.Si est null, rien n'est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un terminateur de ligne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Implémente qui lit une chaîne. - 2 - - - Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. - Chaîne à laquelle doit être initialisé. - Le paramètre est null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Retourne le prochain caractère disponible, mais ne le consomme pas. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Le lecteur actuel est fermé. - 2 - - - Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. - Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. - Le lecteur actuel est fermé. - 2 - - - Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . - Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Index de début dans la mémoire tampon. - Nombre de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Le lecteur actuel est fermé. - 2 - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. - Le lecteur actuel est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - 2 - - - Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. - Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le lecteur actuel est fermé. - 2 - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. - Le nombre de caractères est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. - Objet qui contrôle la mise en forme. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié. - StringBuilder dans lequel écrire. - - a la valeur null. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. - StringBuilder dans lequel écrire. - Objet qui contrôle la mise en forme. - - a la valeur null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Obtient le dans lequel la sortie est écrite. - Encoding dans lequel la sortie est écrite. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - - - Retourne le sous-jacent. - StringBuilder sous-jacent. - 2 - - - Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. - Chaîne contenant les caractères écrits dans le StringWriter en cours. - 2 - - - Écrit un caractère dans la chaîne. - Caractère à écrire. - Le writer est fermé. - 2 - - - Écrit un sous-tableau de caractères dans la chaîne. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - ou est négatif. - ( + )> .Length. - Le writer est fermé. - 2 - - - Écrit une chaîne dans la chaîne actuelle. - Chaîne à écrire. - Le writer est fermé. - 2 - - - Écrit un caractère dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans la chaîne actuelle de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Représente un lecteur capable de lire une série séquentielle de caractères. - 2 - - - Initialise une nouvelle instance de la classe . - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Fournit un TextReader sans données à lire. - 1 - - - Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. - Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. - Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. - La ligne suivante du lecteur ou null si tous les caractères ont été lus. - Une erreur d'E/S se produit. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - - est fermé. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. - Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. - Une erreur d'E/S se produit. - - est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. - Le nombre de caractères est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. - Objet qui contrôle la mise en forme. - - - Stocke les caractères de saut de ligne utilisés pour ce TextWriter. - - - Libère toutes les ressources utilisées par l'objet . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. - Encodage de caractères dans lequel la sortie est écrite. - 1 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le writer de texte est supprimé. - Le writer est actuellement utilisé par une opération d'écriture précédente. - - - Obtient un objet qui contrôle la mise en forme. - Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. - 2 - - - Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. - Chaîne de marque de fin de ligne pour le TextWriter actuel. - 2 - - - Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. - Objet à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne dans la chaîne ou le flux de texte. - Chaîne à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - - ou a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - Dans , position de caractère à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - Une chaîne ou un objet est passé en tant que null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml deleted file mode 100644 index 46070bec..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/it/System.IO.xml +++ /dev/null @@ -1,2123 +0,0 @@ - - - - System.IO - - - - Legge i tipi di dati primitivi come valori binari in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. - Flusso di input. - Il flusso non supporta la lettura, è null o è già chiuso. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. - Flusso di input. - Codifica dei caratteri da usare. - Il flusso non supporta la lettura, è null o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. - Flusso di input. - Codifica dei caratteri da usare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la lettura, è null o è già chiuso. - - o è null. - - - Espone l'accesso al flusso sottostante dell'oggetto . - Flusso sottostante associato all'oggetto BinaryReader. - 2 - - - Rilascia tutte le risorse usate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Inserisce nel buffer interno il numero specificato di byte letti dal flusso. - Numero di byte da leggere. - È stata raggiunta la fine del flusso prima che fosse possibile leggere . - Si è verificato un errore di I/O. - I richiesti sono superiori alla dimensione del buffer interno. - - - Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. - Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. - 2 - - - Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. - Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. - Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di byte da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. - Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di caratteri da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero a 32 bit in formato compresso. - Intero a 32 bit in formato compresso. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - Flusso danneggiato. - - - Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - true se il byte è diverso da zero; in caso contrario, false. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - Byte successivo letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. - Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. - Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è negativo. - 2 - - - Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Carattere letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - È stato letto un carattere surrogato. - 2 - - - Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. - Numero di caratteri da leggere. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Il flusso è chiuso. - Si è verificato un errore di I/O. - - è negativo. - 2 - - - Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. - Valore decimale letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. - Valore a virgola mobile a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. - Intero con segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Intero con segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. - Intero con segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. - Byte con segno letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Valore a virgola mobile a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. - Stringa da leggere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. - Intero senza segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero senza segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero senza segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe che scrive in un flusso. - - - Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. - Flusso di output. - Il flusso non supporta la scrittura o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. - Flusso di output. - Codifica dei caratteri da utilizzare. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. - Flusso di output. - Codifica dei caratteri da utilizzare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Ottiene il flusso sottostante dell'oggetto . - Flusso sottostante associato a BinaryWriter. - 1 - - - Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Specifica un oggetto privo di archivio di backup. - 1 - - - Contiene il flusso principale. - - - Imposta la posizione all'interno del flusso corrente. - Posizione all'interno del flusso corrente. - Offset dei byte relativo a . - Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. - Il puntatore a file è stato spostato in un percorso non valido. - Il valore di non è valido. - 1 - - - Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. - Valore Boolean da scrivere (0 o 1). - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una matrice di byte nel flusso sottostante. - Matrice di caratteri che contiene i dati da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è null. - 1 - - - Scrive un'area di una matrice di byte nel flusso corrente. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale nel parametro da cui iniziare la scrittura. - Numero di byte da scrivere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Carattere Unicode non surrogato da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è un carattere surrogato singolo. - 1 - - - Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - - è null. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 1 - - - Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale in dal quale avviare la scrittura. - Numero di caratteri da inserire. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. - Valore decimale da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Valore a virgola mobile a otto byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Valore a virgola mobile a quattro byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. - Valore da scrivere. - Si è verificato un errore di I/O. - - è null. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Inserisce un valore intero a 32 bit in un formato compresso. - Intero da 32 bit da scrivere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Il flusso è chiuso. - - - Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. - 2 - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - - - Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Eccezione generata se un flusso di dati è in un formato non valido. - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con un messaggio di errore specificato. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - - - Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. - Matrice di byte senza segno da cui creare il flusso corrente. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - - è null. - - o è minore di zero. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - o è un valore negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. - - è null. - Il valore di o è negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. - Dimensione iniziale in byte della matrice interna. - - è negativo. - - - Ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 2 - - - Ottiene o imposta il numero di byte allocati per questo flusso. - Lunghezza della parte usabile del buffer per il flusso. - È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. - Il flusso corrente è chiuso. - set è stato richiamato su un flusso del quale non è possibile modificare la capacità. - 2 - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. - Token da monitorare per le richieste di annullamento. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. - 2 - - - Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento. - Il flusso è stato eliminato. - - - Ottiene la lunghezza in byte del flusso. - Lunghezza del flusso in byte. - Il flusso è chiuso. - 2 - - - Ottiene o imposta la posizione corrente all'interno del flusso. - Posizione corrente all'interno del flusso. - La posizione è impostata su un valore negativo o maggiore di . - Il flusso è chiuso. - 2 - - - Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. - Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. - Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. - Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - - sottratto alla lunghezza del buffer è minore di . - L'istanza del flusso corrente è chiusa. - 2 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso corrente. - Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la posizione all'interno del flusso corrente sul valore specificato. - Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. - Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. - Valore di tipo , che funge da punto di riferimento per la ricerca. - La ricerca viene tentata prima dell'inizio del flusso. - - è maggiore di . - Il valore di non è valido. -oppure- causato da un overflow aritmetico. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la lunghezza del flusso corrente sul valore specificato. - Valore su cui impostare la lunghezza. - Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. - - è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. - 2 - - - Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . - Nuova matrice di byte. - 2 - - - Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. - true se la conversione riesce; in caso contrario, false. - Segmento di matrice di byte da cui è stato creato questo flusso. - - - Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero massimo di byte da scrivere. - - è null. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. - - sottratto alla lunghezza del buffer è minore di . - - o è un valore negativo. - Si è verificato un errore di I/O. - L'istanza del flusso corrente è chiusa. - 2 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente all'interno del flusso corrente. - Byte da scrivere. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. - Il flusso corrente è chiuso. - 2 - - - Scrive l'intero contenuto del flusso di memoria in un altro flusso. - Flusso in cui scrivere il flusso di memoria. - - è null. - Il flusso corrente o di destinazione è chiuso. - 2 - - - Specifica la posizione in un flusso da utilizzare per le ricerche. - 2 - - - Specifica l'inizio di un flusso. - - - Specifica la posizione corrente all'interno di un flusso. - - - Specifica la fine di un flusso. - - - Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe . - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso supporta la lettura; in caso contrario, false. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso supporta la ricerca; in caso contrario, false. - 1 - - - Ottiene un valore che determina se il flusso corrente prevede il timeout. - Valore che determina se il flusso corrente prevede il timeout. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 1 - - - Legge i byte dal flusso corrente e li scrive in un altro flusso. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Si è verificato un errore di I/O. - 2 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - Il flusso è stato eliminato. - - - Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. - Valore long che rappresenta la lunghezza del flusso in byte. - Una classe derivata da Stream non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Oggetto Stream privo di archivio di backup. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. - Posizione corrente all'interno del flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. - Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. - Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. - Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. - Numero massimo di byte da leggere dal flusso corrente. - La somma di e è maggiore della lunghezza del buffer. - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. - Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. - Nuova posizione all'interno del flusso corrente. - Offset dei byte rispetto al parametro . - Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. - Lunghezza desiderata del flusso corrente in byte. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. - Matrice di byte.Questo metodo copia i byte da nel flusso corrente. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero di byte da scrivere nel flusso corrente. - La somma di  e  è maggiore della lunghezza del buffer. - - è null. - - o  è negativo. - Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. - Il flusso non supporta la scrittura. - - è stato chiamato dopo la chiusura del flusso. - 1 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. - Byte da scrivere nel flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura o è già chiuso. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato. - Flusso da leggere. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. - Flusso da leggere. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. - Flusso da leggere. - Codifica dei caratteri da usare. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - Dimensione minima del buffer. - Il flusso non supporta la lettura. - - o è null. - - è minore o uguale a zero. - - - Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. - Flusso da leggere. - Codifica dei caratteri da usare. - true per cercare i byte order mark all'inizio del file; in caso contrario, false. - Dimensione minima del buffer. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - - Restituisce il flusso sottostante. - Flusso sottostante. - 2 - - - Ottiene la codifica caratteri corrente usata dall'oggetto corrente. - Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . - 2 - - - Cancella il buffer interno. - 2 - - - Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. - true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. - Il flusso sottostante è stato eliminato. - 1 - - - Oggetto che include un flusso vuoto. - 1 - - - Restituisce il carattere successivo disponibile senza usarlo. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. - Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Indice di da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O, come la chiusura del flusso. - 1 - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. - Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. - Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. - Il numero di caratteri è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. - Flusso in cui scrivere. - - non è modificabile. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - - o è null. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - - o è null. - - è negativo. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - o è null. - - è negativo. - - non è modificabile. - - - Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . - true per forzare lo scaricamento del buffer; in caso contrario, false. - 1 - - - Ottiene il flusso sottostante che si interfaccia con un archivio di backup. - Flusso in cui StreamWriter scrive. - 2 - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - - - Ottiene l'oggetto in cui viene scritto l'output. - Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. - 2 - - - Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. - Il writer corrente è chiuso. - Si è verificato un errore di I/O. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive un carattere nel flusso. - Carattere da scrivere nel flusso. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una matrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una sottomatrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una stringa nel flusso. - Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Implementa un oggetto che legge da una stringa. - 2 - - - Inizializza una nuova istanza della classe che legge dalla stringa specificata. - Stringa sulla quale inizializzare . - Il parametro è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Restituisce il carattere successivo disponibile senza utilizzarlo. - Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Il lettore corrente è chiuso. - 2 - - - Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. - Il lettore corrente è chiuso. - 2 - - - Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . - Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Indice iniziale nel buffer. - Numero di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. - Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. - Il lettore corrente è chiuso. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - 2 - - - Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Contenuto dalla posizione corrente alla fine della stringa sottostante. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. - Il numero di caratteri è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il controllo di formato specificato. - Oggetto che controlla la formattazione. - - - Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. - Oggetto StringBuilder in cui scrivere. - - è null. - - - Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. - Oggetto StringBuilder in cui scrivere. - Oggetto che controlla la formattazione. - - è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Recupera l'oggetto in cui viene scritto l'output. - Encoding in cui viene scritto l'output. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di svuotamento asincrona. - - - Restituisce l'oggetto sottostante. - StringBuilder sottostante. - 2 - - - Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. - Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. - 2 - - - Scrive un carattere nella stringa. - Carattere da inserire. - Il writer è chiuso. - 2 - - - Scrive una sottomatrice di caratteri nella stringa. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - Il valore di o è negativo. - ( + )> .Length. - Il writer è chiuso. - 2 - - - Scrive una stringa nella stringa corrente. - Stringa da scrivere. - Il writer è chiuso. - 2 - - - Scrive un carattere nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nella stringa corrente in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. - 2 - - - Inizializza una nuova istanza della classe . - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. - 1 - - - Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. - Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 2 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. - Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. - Si è verificato un errore di I/O. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - La classe è chiusa. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. - Si è verificato un errore di I/O. - La classe è chiusa. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. - Il numero di caratteri è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il provider di formato specificato. - Oggetto che controlla la formattazione. - - - Archivia i caratteri di nuova riga usati per questo TextWriter. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. - Codifica caratteri in cui viene scritto l'output. - 1 - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il writer di testo viene eliminato. - Il writer è attualmente utilizzato da un'operazione di scrittura precedente. - - - Ottiene un oggetto che controlla la formattazione. - Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. - 2 - - - Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. - Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. - 2 - - - Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nella stringa o flusso di testo. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri nella stringa o flusso di testo. - Matrice di caratteri da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. - Oggetto da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa nella stringa o nel flusso di testo. - Stringa da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - - o è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso o nella stringa di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - Posizione del carattere in dalla quale avviare la lettura dei dati. - Numero massimo di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - Viene passato un oggetto o una stringa come null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml deleted file mode 100644 index 4114d626..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/ja/System.IO.xml +++ /dev/null @@ -1,2264 +0,0 @@ - - - - System.IO - - - - プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 - 2 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - 使用する文字エンコーディング。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - は null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 入力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - または が null です。 - - - - の基になるストリームへのアクセスを公開します。 - BinaryReader に関連付けられた、基になるストリーム。 - 2 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 - 読み取るバイト数。 - - 分のバイトを読み取る前にストリームの末尾に到達しました。 - I/O エラーが発生しました。 - 要求された が、内部バッファー サイズより大きくなっています。 - - - 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 - 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 - 2 - - - 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 - - に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取るバイト数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 - バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取る文字の数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 32 ビット整数を圧縮形式で読み取ります。 - 圧縮形式の 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - ストリームが破損しています。 - - - 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った次のバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 - 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - が負の値です。 - 2 - - - 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 現在のストリームから読み取った文字。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - サロゲート文字が読み取られました。 - 2 - - - 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 - 読み取る文字の数。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - - が負の値です。 - 2 - - - 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 - 現在のストリームから読み取った 10 進数値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った符号付きバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 - 読み取った文字列。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号なし整数。 - ストリームの末尾に到達しました。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 - 2 - - - ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - は null なので、 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - 使用する文字エンコーディング。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 出力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - - の基になるストリームを取得します。 - BinaryWriter に関連付けられた、基になるストリーム。 - 1 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - バッキング ストアを持たない を指定します。 - 1 - - - 基になるストリームを保持します。 - - - 現在のストリーム内の位置を設定します。 - 現在のストリームの位置。 - - からのバイト オフセット。 - 新しい位置を取得するための参照ポイントを示す フィールド。 - ファイル ポインターが無効な位置に移動しました。 - - 値が無効です。 - 1 - - - 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 - 書き込む Boolean 値 (0 または 1)。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号なしバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 基になるストリームにバイト配列を書き込みます。 - 書き込むデータが格納されているバイト配列。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は null なので、 - 1 - - - 現在のストリームにバイト配列の特定の領域を書き込みます。 - 書き込むデータが格納されているバイト配列。 - - 内の書き込み開始点。 - 書き込むバイト数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む非サロゲート Unicode 文字。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は、単一のサロゲート文字です。 - 1 - - - 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - は null なので、 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - 内の書き込み開始点。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 - 書き込む 10 進値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号付きバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む値。 - I/O エラーが発生しました。 - - は null なので、 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 32 ビット整数を圧縮形式で書き込みます。 - 書き込む 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - ストリームが閉じられました。 - - - ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 - 2 - - - メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 - - - メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - - - 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - データ ストリームが無効な形式である場合にスローされる例外。 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - - - この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 - - - 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - 現在のストリームを作成する符号なしバイトの配列。 - - は null です。 - - - - プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - - バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - - は null です。 - - または が 0 未満です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 - バイト単位の内部配列の初期サイズ。 - - が負の値です。 - - - 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 2 - - - ストリームに割り当てられたバイト数を取得または設定します。 - ストリームに対してバッファーが使用できる部分の長さ。 - 容量が負の値または現在のストリーム長より小さい値に設定されています。 - 現在のストリームが閉じています。 - 容量を変更できないストリームに対して set が呼び出されました。 - 2 - - - 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 - キャンセル要求を監視するためのトークン。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - アクションが実行されないように、 メソッドをオーバーライドします。 - 2 - - - このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。 - ストリームは破棄されています。 - - - バイト単位のストリーム長を取得します。 - バイト単位のストリーム長。 - ストリームが閉じられました。 - 2 - - - ストリームの現在位置を取得または設定します。 - ストリーム内の現在位置。 - 位置が負の値または より大きい値に設定されています。 - ストリームが閉じられました。 - 2 - - - 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 - バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 - このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 - 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームからバイトを読み取ります。 - - にキャストしたバイト。ストリームの末尾に達した場合は -1。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム内の位置を指定した値に設定します。 - 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 - ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 - シーク参照ポイントとして機能する 型の値。 - ストリームの先頭より前をシークしようとしました。 - - が より大きくなっています。 - 無効な があります。または によって算術オーバーフローが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム長を指定した値に設定します。 - 長さを設定する値。 - 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 - - が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 - 2 - - - - プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 - 新しいバイト配列。 - 2 - - - このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 - 変換が成功した場合は true。それ以外の場合は false。 - このストリームの作成元のバイト配列セグメント。 - - - バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 - データの書き込み元となるバッファー。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリーム内の現在位置に 1 バイトを書き込みます。 - 書き込むバイト。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 - 現在のストリームが閉じています。 - 2 - - - メモリ ストリームの内容全体を別のストリームに書き込みます。 - このメモリ ストリームが書き込まれるストリーム。 - - は null です。 - 現在のストリームまたは対象のストリームは閉じています。 - 2 - - - シークに使用するストリームの場所を指定します。 - 2 - - - ストリームの先頭を指定します。 - - - ストリーム内の現在位置を指定します。 - - - ストリームの末尾を指定します。 - - - バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 - ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 - ストリームがシークをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 - 現在のストリームがタイムアウトできるかどうかを決定する値。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - によって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - I/O エラーが発生しました。 - 2 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。既定値は です。 - ストリームは破棄されています。 - - - 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 - ストリーム長 (バイト単位) を表す long 値。 - Stream から派生したクラスがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - バッキング ストアを持たない Stream。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 - ストリーム内の現在位置。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 - バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 - バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 - 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームから読み取る最大バイト数。 - - と の合計値が、バッファー長より大きい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 - Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 - 現在のストリーム内の新しい位置。 - - パラメーターからの相対バイト オフセット。 - 新しい位置を取得するために使用する参照ポイントを示す 型の値。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 - 現在のストリームの希望の長さ (バイト数)。 - I/O エラーが発生しました。 - ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 - バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームに書き込むバイト数。 - 合計  と  がバッファーの長さより大きい。 - - nullです。 - - または  が負の値です。 - 指定したファイルが見つからないなど、I/O エラーが発生しました。 - ストリームは書き込みをサポートしません。 - - ストリームが閉じられた後が呼び出されました。 - 1 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - ストリームに書き込むバイト。 - I/O エラーが発生しました。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 1 - - - 指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - - が読み取りをサポートしていません。 - - は null です。 - - - バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - は null です。 - - - 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - 最小バッファー サイズ。 - ストリームは読み取りをサポートしません。 - - または が null です。 - - が 0 以下です。 - - - 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 読み取るストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 - 最小バッファー サイズ。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - - - 基になるストリームを返します。 - 基になるストリーム。 - 2 - - - 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 - 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 - 2 - - - 内部バッファーをクリアします。 - 2 - - - 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 - 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 - 基になるストリームは破棄されています。 - 1 - - - 空のストリームの オブジェクト。 - 1 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 - 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 - 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みの開始位置を示す のインデックス。 - 読み取り対象の最大文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。たとえば、ストリームがクローズされています。 - 1 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 - 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - すべての文字の現在位置から末尾までを読み込みます。 - ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 - 1 - - - UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - - が書き込み可能ではありません。 - - は null です。 - - - 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - - または が null です。 - - が書き込み可能ではありません。 - - - 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - true to leave the stream open after the object is disposed; otherwise, false. - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - - が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 - - に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 - 1 - - - バッキング ストアと連結する、基になるストリームを取得します。 - この StreamWriter が書き込むストリーム。 - 2 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - - - 出力の書き込みに使用する を取得します。 - 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 - 2 - - - 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 - 現在のライターがクローズされています。 - I/O エラーが発生しました。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - 1 - - - このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 - 1 - - - ストリームに文字を書き込みます。 - ストリームに書き込む文字。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列を書き込みます。 - 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列の一部を書き込みます。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字列を書き込みます。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - I/O エラーが発生しました。 - 1 - - - 文字を非同期でストリームに書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列から読み取る を実装します。 - 2 - - - 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 - - を初期化する目的の文字列。 - - パラメーターが null です。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 - 基になる文字列の次の文字。または使用できる文字がない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 - バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - バッファー内の開始インデックス。 - 読み取る文字の数。 - - は null なので、 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - 現在のリーダーが閉じています。 - 2 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 - 現在の文字列の次の行。文字列の末尾に到達した場合は null。 - 現在のリーダーが閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 2 - - - 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 - 基になる文字列の現在位置から末尾までの内容。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 現在のリーダーが閉じています。 - 2 - - - 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - - は null なので、 - - - 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - 書式を制御する オブジェクト。 - - は null なので、 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 出力の書き込みに使用する を取得します。 - 出力の書き込み時に適用する Encoding。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - - - 基になる を返します。 - 基になる StringBuilder。 - 2 - - - 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 - 現在の StringWriter に書き込まれた文字を格納している文字列。 - 2 - - - 文字列に文字を書き込みます。 - 書き込む文字。 - ライターが閉じられました。 - 2 - - - 文字配列の一部を文字列に書き込みます。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - または が負の値です。 - ( + )> 。Length. - ライターが閉じられました。 - 2 - - - 現在の文字列に文字列を書き込みます。 - 書き込む文字列。 - ライターが閉じられました。 - 2 - - - 文字列に文字を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に文字列を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 一連の文字を読み取ることができるリーダーを表します。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り対象のデータを TextReader に提供しません。 - 1 - - - リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 - テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 2 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 - リーダーの次の行。またはすべての文字が読み取られた場合は null。 - I/O エラーが発生しました。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - - が閉じています。 - 次の行の文字数が、 を超えています。 - 1 - - - 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 - テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 - I/O エラーが発生しました。 - - が閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 次の行の文字数が、 を超えています。 - 1 - - - テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - この TextWriter で使用する改行文字を格納します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 - 出力の書き込み時に適用する文字エンコーディング。 - 1 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - テキスト ライターは破棄されます。 - ライターは現在、前の書き込み操作で使用中です。 - - - 書式を制御するオブジェクトを取得します。 - 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 - 2 - - - 現在の TextWriter で使用される行終端文字列を取得または設定します。 - 現在の TextWriter で使用する行終端文字列。 - 2 - - - バッキング ストアを持たない書き込み専用の TextWriter を提供します。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字配列をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込みます。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込むオブジェクト。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込みます。 - 書き込む文字列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - - または が null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をテキスト文字列またはストリームに書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - データの読み込みを開始する、 内の文字の位置。 - 書き込む文字の最大数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - 文字列またはオブジェクトが null として渡されました。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml deleted file mode 100644 index 145ab498..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/ko/System.IO.xml +++ /dev/null @@ -1,2262 +0,0 @@ - - - - System.IO - - - - 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. - 2 - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 가 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 또는 가 null인 경우 - - - - 의 내부 스트림에 대한 액세스를 노출합니다. - BinaryReader와 관련된 내부 스트림입니다. - 2 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. - 읽을 바이트 수입니다. - - 를 읽기 전에 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 요청된 가 내부 버퍼 크기보다 큰 경우 - - - 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. - 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. - 2 - - - 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. - - 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 압축 형식의 32비트 정수를 읽습니다. - 압축 형식의 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 스트림이 손상되었습니다. - - - 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 바이트가 0이 아니면 true이고 0이면 false입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 다음 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. - 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 현재 스트림에서 읽은 문자입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 서로게이트 문자를 읽은 경우 - 2 - - - 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. - 읽을 문자 수입니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 10진 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. - 읽어 오는 문자열입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. - 2 - - - 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 가 null입니다. - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - - 의 내부 스트림을 가져옵니다. - BinaryWriter와 관련된 내부 스트림입니다. - 1 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 1 - - - 백업 저장소가 없는 를 지정합니다. - 1 - - - 내부 스트림을 보유합니다. - - - 현재 스트림 내에서 위치를 설정합니다. - 현재 스트림에서의 위치입니다. - - 에 상대적인 바이트 오프셋입니다. - 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. - 파일 포인터가 잘못된 위치로 이동한 경우 - - 값이 잘못된 경우 - 1 - - - false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. - 쓸 Boolean 값(0 또는 1)입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 없는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 내부 스트림에 바이트 배열을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 null입니다. - 1 - - - 현재 스트림에 바이트 배열 영역을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 단일 서로게이트 문자인 경우 - 1 - - - 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - - 가 null입니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. - 출력할 10진수 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 있는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - - 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 값입니다. - I/O 오류가 발생하는 경우 - - 가 null입니다. - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 압축 형식의 32비트 정수를 씁니다. - 쓸 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - 스트림이 닫혀 있는 경우 - - - 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. - 2 - - - 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - - 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - - - 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - - - 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 현재 스트림을 만들 부호 없는 바이트의 배열입니다. - - 가 null인 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - - 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - - 가 null인 경우 - - 또는 가 0보다 작은 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 내부 배열의 초기 크기(바이트)입니다. - - 가 음수인 경우 - - - 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 2 - - - 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. - 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. - 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 - 현재 스트림이 닫혀 있는 경우 - 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 - 2 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. - 취소 요청을 모니터링할 토큰입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - - 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다. - 스트림이 삭제된 경우 - - - 스트림의 길이(바이트)를 가져옵니다. - 스트림의 길이(바이트)입니다. - 스트림이 닫혀 있는 경우 - 2 - - - 스트림 내의 현재 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - 위치가 음수 값이나 보다 큰 값으로 설정된 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. - 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. - 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트를 읽습니다. - - 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림 내의 위치를 지정된 값으로 설정합니다. - 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. - 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. - 검색 참조 지점 역할을 하는 형식의 값입니다. - 스트림의 시작 전에 검색하려고 한 경우 - - 가 보다 큰 경우 - 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림의 길이를 지정된 값으로 설정합니다. - 길이를 설정할 값입니다. - 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 - - 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. - 2 - - - - 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. - 새 바이트 배열입니다. - 2 - - - 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. - 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. - 이 스트림을 만든 바이트 배열 세그먼트입니다. - - - 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. - 데이터를 쓸 버퍼입니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 위치에서 현재 스트림에 바이트를 씁니다. - 쓸 바이트입니다. - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 - 현재 스트림이 닫혀 있는 경우 - 2 - - - 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. - 이 메모리 스트림을 쓸 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 닫혀 있는 경우 - 2 - - - 탐색에 사용할 스트림 내 위치를 지정합니다. - 2 - - - 스트림의 맨 앞을 지정합니다. - - - 스트림 내의 현재 위치를 지정합니다. - - - 스트림의 맨 끝을 지정합니다. - - - 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. - 2 - - - 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 에서 사용하는 모든 리소스를 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. - I/O 오류가 발생하는 경우 - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - 스트림이 삭제된 경우 - - - 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. - 스트림 길이(바이트)를 나타내는 long 값입니다. - Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 백업 저장소가 없는 Stream입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - I/O 오류가 발생하는 경우 - 스트림이 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. - 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. - 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에서 읽을 최대 바이트 수입니다. - - 와 의 합계가 버퍼 길이보다 큰 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. - Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. - 현재 스트림 내의 새 위치입니다. - - 매개 변수에 상대적인 바이트 오프셋입니다. - 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. - 원하는 현재 스트림의 길이(바이트)입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. - 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에 쓸 바이트 수입니다. - 총  및  버퍼 길이 보다 큽니다. - - null입니다. - - 또는  음수입니다. - 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. - 스트림이 쓰기를 지원하지 않습니다. - - 스트림이 닫힌 후 호출 되었습니다. - 1 - - - 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. - 스트림에 쓸 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 1 - - - 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - 최소 버퍼 크기입니다. - 스트림이 읽기를 지원하지 않습니다. - - 또는 가 null인 경우 - - 가 0보다 작거나 같은 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. - 최소 버퍼 크기입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - - - 내부 스트림을 반환합니다. - 내부 스트림입니다. - 2 - - - 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. - 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. - 2 - - - 내부 버퍼를 지웁니다. - 2 - - - 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. - 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. - 내부 스트림이 삭제된 경우 - 1 - - - 빈 스트림 주위의 개체입니다. - 1 - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - - 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. - 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 인덱스입니다. - 읽을 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫히는 등의 I/O 오류가 발생한 경우 - 1 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. - 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - - 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. - 1 - - - UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - - 에 쓸 수 없는 경우 - - 가 null인 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - - 또는 가 null인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - true to leave the stream open after the object is disposed; otherwise, false. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - - 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. - - 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. - 1 - - - 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. - 이 StreamWriter가 쓰고 있는 스트림입니다. - 2 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - - - 출력이 쓰여질 을 가져옵니다. - 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. - 2 - - - 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. - 현재 writer가 닫힌 경우 - I/O 오류가 발생한 경우 - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - 1 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. - 1 - - - 스트림에 문자를 씁니다. - 스트림에 쓸 문자입니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자의 하위 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자열을 씁니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작할 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 줄 종결자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열에서 읽어오는 를 구현합니다. - 2 - - - 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. - - 가 초기화되어야 하는 문자열입니다. - - 매개 변수가 null인 경우 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 버퍼의 시작 인덱스입니다. - 읽을 문자 수입니다. - - 가 null입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. - 현재 판독기가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 2 - - - 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. - 내부 문자열의 현재 위치에서 끝까지의 내용입니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 형식 지정을 제어하는 개체입니다. - - - 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - - 가 null입니다. - - - 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - 형식 지정을 제어하는 개체입니다. - - 가 null입니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 출력이 쓰여질 을 가져옵니다. - 출력이 쓰여질 Encoding입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 비동기 플러시 작업을 나타내는 작업입니다. - - - 내부 를 반환합니다. - 내부 StringBuilder입니다. - 2 - - - 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. - 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. - 2 - - - 문자를 문자열에 씁니다. - 쓸 문자입니다. - 작성기가 닫힌 경우 - 2 - - - 문자의 하위 배열을 문자열에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 또는 가 음수인 경우 - ( + )> 인 경우Length. - 작성기가 닫힌 경우 - 2 - - - 문자를 현재 문자열에 씁니다. - 쓸 문자열입니다. - 작성기가 닫힌 경우 - 2 - - - 문자를 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자를 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - TextReader에 읽을 데이터를 제공하지 않습니다. - 1 - - - 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. - I/O 오류가 발생하는 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - - 가 닫힌 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. - I/O 오류가 발생하는 경우 - - 가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 서식 지정을 제어하는 개체입니다. - - - 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. - 출력을 쓰는 문자 인코딩입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. - - - 서식 지정을 제어하는 개체를 가져옵니다. - 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. - 2 - - - 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. - 현재 TextWriter의 줄 종결자 문자열입니다. - 2 - - - 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. - 1 - - - Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - - 또는 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - 데이터 읽기를 시작하는 의 문자 위치입니다. - 쓸 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - 문자열이나 개체가 null로 전달되는 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml deleted file mode 100644 index d9ad6103..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/ru/System.IO.xml +++ /dev/null @@ -1,2023 +0,0 @@ - - - - System.IO - - - - Считывает примитивные типы данных как двоичные значения в заданной кодировке. - 2 - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Входной поток. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. - Входной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Входной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Параметр или имеет значение null. - - - Предоставляет доступ к базовому потоку объекта . - Базовый поток, связанный с объектом BinaryReader. - 2 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. - Количество байтов, чтение которых необходимо выполнить. - Конец потока достигнут раньше, чем было выполнено чтение байтов. - Ошибка ввода-вывода. - Запрошенное значение превышает размер внутреннего буфера. - - - Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. - Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. - Ошибка ввода-вывода. - Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. - 2 - - - Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. - Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Количество байтов, чтение которых необходимо выполнить. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. - Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Число символов для чтения. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число в сжатом формате. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Поток поврежден. - - - Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. - Значение true, если байт не равен нулю; в противном случае — значение false. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. - Следующий байт, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. - Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. - Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Ошибка ввода-вывода. - Поток закрыт. - Значение отрицательно. - 2 - - - Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Символ, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Выполнено чтение символа-заместителя. - 2 - - - Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. - Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. - Количество символов, которое необходимо считать. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Поток закрыт. - Ошибка ввода-вывода. - Значение отрицательно. - 2 - - - Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. - Десятичное значение, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Число с плавающей запятой длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Целое число со знаком длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. - Байт со знаком, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Число с плавающей запятой длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. - Считываемая строка. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число без знака длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число без знака длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. - Целое число без знака длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. - 2 - - - Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Выходной поток. - Поток не поддерживает запись или был закрыт до начала операции. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. - Выходной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Выходной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Получает базовый поток . - Базовый поток, связанный с объектом BinaryWriter. - 1 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Задает без резервного хранилища. - 1 - - - Содержит базовый поток. - - - Задает позицию в текущем потоке. - Позиция в текущем потоке. - Смещение в байтах относительно . - Поле указывает точку отсчета, относительно которой указывается новая позиция. - Указатель позиции в файле перемещен в недопустимую позицию. - Значение является недопустимым. - 1 - - - Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. - Записываемое в поток значение типа Boolean (0 или 1). - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. - Записываемый в поток байт без знака. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись массива байтов в базовый поток. - Массив байтов, содержащий записываемые в поток данные. - Ошибка ввода-вывода. - Поток закрыт. - Параметр имеет значение null. - 1 - - - Выполняет запись части массива байтов в текущий поток. - Массив байтов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество записываемых байтов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. - Незаменяющий символ Юникода, который необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - - представляет собой единичный символ-заместитель. - 1 - - - Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. - Массив символов, содержащий записываемые в поток данные. - Параметр имеет значение null. - Поток закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. - Массив символов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. - Десятичное значение, которое необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число со знаком размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число со знаком размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число со знаком размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. - Байт со знаком, который необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. - Записываемое значение. - Ошибка ввода-вывода. - Параметр имеет значение null. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число без знака размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число без знака размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число без знака размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число, которое необходимо записать. - Достигнут конец потока. - Поток закрыт. - Поток закрыт. - - - Исключение, которое создается при попытке выполнить чтение за пределами потока. - 2 - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - - - Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Исключение возникает, когда поток данных имеет недопустимый формат. - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным сообщением об ошибке. - Сообщение об ошибке с объяснением причин исключения. - - - Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. - Сообщение об ошибке с объяснением причин исключения. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. - Массив байтов без знака, из которого создается текущий поток. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Свойство имеет значение null. - Значение параметра или меньше нуля. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - Параметр или имеет отрицательное значение. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. - Исходный размер внутреннего массива в байтах. - Значение отрицательно. - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 2 - - - Возвращает или задает число байтов, выделенных для этого потока. - Длина применимой к использованию части буфера для потока. - Заданная емкость отрицательная или меньше текущей длины потока. - Текущий поток закрыт. - set вызывается для потока, емкость которого нельзя изменить. - 2 - - - Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля. - Токен для отслеживания запросов отмены. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Переопределяет метод так, что никакие действия не выполняются. - 2 - - - Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены. - Поток был ликвидирован. - - - Возвращает длину потока в байтах. - Длина потока в байтах. - Поток закрыт. - 2 - - - Возвращает или задает текущее положение в потоке. - Текущее положение в потоке. - В качестве положения задано отрицательное значение или значение, большее . - Поток закрыт. - 2 - - - Считывает блок байтов из текущего потока и записывает данные в буфер. - Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. - При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом меньше, чем . - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из текущего потока. - Байт приводится к типу или -1, если достигнут конец потока. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для положения в текущем потоке. - Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. - Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. - Значение типа , которое действует как точка ссылки поиска. - Попытка поиска выполняется до начала потока. - Значение больше значения . - - недопустим. -или-Значение вызвало арифметическое переполнение. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для длины текущего потока. - Значение задаваемой длины. - Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. - Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. - 2 - - - Записывает содержимое потока в массив байтов независимо от свойства . - Новый массив байтов. - 2 - - - Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. - Значение true, если преобразование прошло успешно; в противном случае — значение false. - Сегмент массива байтов, из которого был создан данный поток. - - - Записывает в текущий поток блок байтов, используя данные, считанные из буфера. - Буфер, из которого записываются данные. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. - Длина буфера за вычетом меньше, чем . - Параметр или имеет отрицательное значение. - Ошибка ввода-вывода. - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение текущего потока. - Записываемый байт. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. - Текущий поток закрыт. - 2 - - - Записывает все содержимое данного потока памяти в другой поток. - Поток, в который требуется осуществить запись данного потока памяти. - Свойство имеет значение null. - Текущий или конечный поток закрыт. - 2 - - - Задает позицию в потоке, используемую для поиска. - 2 - - - Задает начало потока. - - - Задает текущее положение в потоке. - - - Задает конец потока. - - - Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса . - - - При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. - Значение true, если поток поддерживает чтение; в противном случае — значение false. - 1 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. - Значение true, если поток поддерживает поиск; в противном случае — значение false. - 1 - - - Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. - Значение, которое показывает, может ли для данного потока истечь время ожидания. - 2 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 1 - - - Считывает байты из текущего потока и записывает их в другой поток. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Поток, в который будет скопировано содержимое текущего потока. - Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает все ресурсы, занятые модулем . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. - Ошибка ввода-вывода. - 2 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Поток был ликвидирован. - - - При переопределении в производном классе получает длину потока в байтах. - Длинное значение, представляющее длину потока в байтах. - Класс, созданный на основе класса Stream, не поддерживает возможность поиска. - Методы были вызваны после закрытия потока. - 1 - - - Объект Stream без резервного хранилища. - 1 - - - При переопределении в производном классе получает или задает позицию в текущем потоке. - Текущее положение в потоке. - Ошибка ввода-вывода. - Этот поток не поддерживает поиск. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. - Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. - Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. - Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. - Максимальное количество байтов, которое должно быть считано из текущего потока. - Сумма значений параметров и больше длины буфера. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 1 - - - Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. - Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - При переопределении в производном классе задает позицию в текущем потоке. - Новая позиция в текущем потоке. - Смещение в байтах относительно параметра . - Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. - Ошибка ввода-вывода. - Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе задает длину текущего потока. - Нужная длина текущего потока в байтах. - Ошибка ввода-вывода. - Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 2 - - - При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. - Массив байтов.Этот метод копирует байты из в текущий поток. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Количество байтов, которое необходимо записать в текущий поток. - Сумма  и  больше, чем длина буфера. - - — null. - - или  является отрицательным. - Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. - Поток не поддерживает запись. - - был вызван после закрытия потока. - 1 - - - Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. - Байт, записываемый в поток. - Ошибка ввода-вывода. - Поток не поддерживает запись или был закрыт до начала операции. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 1 - - - Инициализирует новый экземпляр класса для заданного потока. - Поток, который нужно считать. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. - Поток, который нужно считать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - Минимальный размер буфера. - Поток не поддерживает чтение. - Параметр или имеет значение null. - Значение параметра меньше или равно нулю. - - - Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. - Считываемый поток. - Кодировка символов, которую нужно использовать. - Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. - Минимальный размер буфера. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - - - Возвращает основной поток. - Основной поток. - 2 - - - Возвращает текущую кодировку символов, используемую текущим объектом . - Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. - 2 - - - Очищает внутренний буфер. - 2 - - - Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. - Значение true, если текущее положение находится в конце потока; в противном случае — значение false. - Основной поток удален. - 1 - - - Объект для пустого потока. - 1 - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. - Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. - Ошибка ввода-вывода. - 1 - - - Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. - Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Индекс , с которого требуется начать запись. - Максимальное число считываемых символов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Возникает ошибка ввода-вывода, например закрывается поток. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Произошла ошибка ввода-вывода. - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Следующая строка из входного потока или значение null, если достигнут конец входного потока. - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. - Количество символов в следующей строке больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца потока. - Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. - Количество символов больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. - 1 - - - Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Запись в поток запрещена. - - is null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Значение параметра или — null. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . - Значение true, чтобы заставить сбросить буфер; в противном случае — false. - 1 - - - Получает основной поток, связанный с резервным хранилищем. - Поток, в который StreamWriter выполняет запись. - 2 - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. - 2 - - - Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. - Текущее средство записи закрывается. - Произошла ошибка ввода-вывода. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - 1 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает символ в поток. - Символ, записываемый в поток. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток массив символов. - Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток дочерний массив символов. - Массив символов, содержащий записываемые данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток строку. - Строка, записываемая в поток.Если равняется null, запись не выполняется. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает символ в поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, содержащий записываемые данные. - Положение символа в буфере с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает строку в поток. - Задача, представляющая асинхронную операцию записи. - Строка, записываемая в поток.Если имеет значение null, запись не выполняется. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток признак конца строки. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Реализует класс , осуществляющий чтение из строки. - 2 - - - Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. - Строка, для которой должен быть инициализирован класс . - Значение параметра — null. - - - Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. - Текущее средство чтения закрыто. - 2 - - - Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. - Следующий символ из основной строки или значение -1, если больше нет доступных символов. - Текущее средство чтения закрыто. - 2 - - - Считывает блок символов из строки ввода и увеличивает позицию символов на . - Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Начальный индекс в буфере. - Количество символов, которые необходимо считать. - Параметр имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Следующая строка из текущей строки, или значение null, если достигнут конец строки. - Текущее средство чтения закрыто. - Недостаточно памяти для размещения буфера возвращаемых строк. - 2 - - - Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Содержимое, начиная от текущей позиции до конца основной строки. - Недостаточно памяти для размещения буфера возвращаемых строк. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. - Количество символов больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи данных в строку.Данные хранятся в основном . - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным форматом объекта. - Объект , управляющий форматированием. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . - Класс StringBuilder, в который осуществляется запись. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. - Класс StringBuilder, в который осуществляется запись. - Объект , управляющий форматированием. - Параметр имеет значение null. - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Encoding, в которой осуществляется запись выходных данных. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - - - Возвращает основной . - Базовый StringBuilder. - 2 - - - Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. - Строка, содержащая символы, записанные в текущий StringWriter. - 2 - - - Записывает символ в строку. - Символ для записи. - Средство записи закрыто. - 2 - - - Записывает в строку дочерний массив символов. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Значение параметра или является отрицательным. - ( + )> .Length. - Средство записи закрыто. - 2 - - - Записывает строку в текущую строку. - Строка для записи. - Средство записи закрыто. - 2 - - - Выполняет асинхронную запись символа в строку. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в строку. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текущую строку. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в строку символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Представляет средство чтения, позволяющее считывать последовательные наборы символов. - 2 - - - Инициализирует новый экземпляр класса . - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Предоставляет TextReader без данных, доступных для чтения. - 1 - - - Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. - Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. - При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. - Следующая строка из средства чтения, или значение null, если все символы считаны. - Ошибка ввода-вывода. - Недостаточно памяти для размещения буфера возвращаемых строк. - Объект закрыт. - Количество символов в следующей строке больше . - 1 - - - Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. - Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. - Ошибка ввода-вывода. - Объект закрыт. - Недостаточно памяти для размещения буфера возвращаемых строк. - Количество символов в следующей строке больше . - 1 - - - Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. - Количество символов больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса указанным поставщиком формата. - Объект , управляющий форматированием. - - - Сохраняет символы новой строки, используемые для данного TextWriter. - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. - Кодировка символов, в которой осуществляется запись выходных данных. - 1 - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Удалено средство записи текста. - Средство записи в настоящее время используется предыдущей операцией записи. - - - Возвращает объект, управляющий форматированием. - Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. - 2 - - - Возвращает или задает признак конца строки, используемой текущим TextWriter. - Признак конца строки для текущего TextWriter. - 2 - - - Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись символа в текстовую строку или поток. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись массива символов в текстовую строку или поток. - Массив символов, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает дочерний массив символов в текстовую строку или поток. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает текстовое представление десятичного значения в текстовую строку или поток. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. - Записываемый объект. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает строку в текстовую строку или поток. - Строка для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Параметр или имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет асинхронную запись символа в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись массива символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Записывает признак конца строки в текстовую строку или поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Положение символа в , с которого начинается чтение данных. - Наибольшее количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. - Записываемый объект.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток строку, за которой следует признак конца строки. - Строка для записи.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Строка или объект передаются в виде null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает признак конца строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml deleted file mode 100644 index cf7eb52f..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/zh-hans/System.IO.xml +++ /dev/null @@ -1,2237 +0,0 @@ - - - - System.IO - - - - 用特定的编码将基元数据类型读作二进制值。 - 2 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输入流。 - 该流不支持读取，为null 或已关闭。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输入流。 - 要使用的字符编码。 - 该流不支持读取，为null 或已关闭。 - - 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输入流。 - 要使用的字符编码。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - 该流不支持读取，为null 或已关闭。 - - 或 为 null。 - - - 公开对 的基础流的访问。 - 与 BinaryReader 关联的基础流。 - 2 - - - 释放 类的当前实例所使用的所有资源。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 用从流中读取的指定字节数填充内部缓冲区。 - 要读取的字节数。 - 在可以读取 之前到达了流的末尾。 - 发生 I/O 错误。 - 请求的 大于内部缓冲区大小。 - - - 返回下一个可用的字符，并且不提升字节或字符的位置。 - 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 - 发生 I/O 错误。 - 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 - 2 - - - 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 输入流中的下一个字符，如果当前无可用字符则为 -1。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 从字节数组中的指定点开始，从流中读取指定的字节数。 - 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字节数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从字符数组中的指定点开始，从流中读取指定的字符数。 - 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字符数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 以压缩格式读入 32 位整数。 - 压缩格式的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 流已损坏。 - - - 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 - 如果字节为非零，则为 true，否则为 false。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的下一个字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 - 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 发生 I/O 错误。 - 流已关闭。 - - 为负数。 - 2 - - - 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 从当前流中读取的字符。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 读取了一个代理项字符。 - 2 - - - 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 - 要读取的字符数。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 流已关闭。 - 发生 I/O 错误。 - - 为负数。 - 2 - - - 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 - 从当前流中读取的十进制数值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的一个有符号字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 4 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 - 正被读取的字符串。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 - 从该流中读取的 2 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 - 从该流中读取的 4 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 - 从该流中读取的 8 字节无符号整数。 - 已到达流的末尾。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 - 2 - - - 初始化向流中写入的 类的新实例。 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输出流。 - 该流不支持写入或者该流已关闭。 - - 为 null。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输出流。 - 要使用的字符编码。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输出流。 - 要使用的字符编码。 - 如果在释放 对象之后打开流对象，则为 true；否则为， false。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 获取 的基础流。 - 与 BinaryWriter 关联的基础流。 - 1 - - - 释放由 类的当前实例占用的所有资源。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 指定无后备存储区的 。 - 1 - - - 持有基础流。 - - - 设置当前流中的位置。 - 包含当前流的位置。 - 相对于 的字节偏移量。 - - 的一个字段，指示获取新位置所依据的参考点。 - 文件指针被移到无效位置。 - - 值无效。 - 1 - - - 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 - 要写入的 Boolean 值（0 或 1）。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的无符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将字节数组写入基础流。 - 包含要写入的数据的字节数组。 - 发生 I/O 错误。 - 流已关闭。 - - 为 null。 - 1 - - - 将字节数组部分写入当前流。 - 包含要写入的数据的字节数组。 - - 中开始写入的起始点。 - 要写入的字节数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 要写入的非代理项 Unicode 字符。 - 发生 I/O 错误。 - 流已关闭。 - - 是单一代理项字符。 - 1 - - - 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 为 null。 - 流已关闭。 - 发生 I/O 错误。 - 1 - - - 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 中开始写入的起始点。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个十进制值写入当前流，并将流位置提升十六个字节。 - 要写入的十进制值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的有符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 - 要写入的值。 - 发生 I/O 错误。 - - 为 null。 - 流已关闭。 - 1 - - - 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 以压缩格式写出 32 位整数。 - 要写出的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 流已关闭。 - - - 读操作试图超出流的末尾时引发的异常。 - 2 - - - 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - - - 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - - - 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 在数据流的格式无效时引发的异常。 - - - 初始化 类的新实例。 - - - 使用指定的错误消息初始化 类的新实例。 - 解释异常原因的错误信息。 - - - 用对作为此异常原因的内部异常的引用初始化 类的新实例。 - 解释异常原因的错误信息。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化为零的可扩展容量初始化 类的新实例。 - - - 基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建当前流的无符号字节数组。 - - 为 null。 - - - 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - - 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 为 null。 - - 或 小于零。 - 缓冲区长度减去 小于 。 - - - 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 使用按指定要求初始化的可扩展容量初始化 类的新实例。 - 内部数组的初始大小（以字节为单位）。 - - 为负数。 - - - 获取一个值，该值指示当前流是否支持读取。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持查找。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持写入。 - 如果流支持写入，则为 true；否则为 false。 - 2 - - - 获取或设置分配给该流的字节数。 - 流的缓冲区的可使用部分的长度。 - 容量设置为负或小于流的当前长度。 - 当前流已关闭。 - 对不能修改其容量的流调用 set。 - 2 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。 - 要监视取消请求的标记。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 重写 方法以便不执行任何操作。 - 2 - - - 异步清除此流的所有缓冲区，并监视取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。 - 流已被释放。 - - - 获取流的长度（以字节为单位）。 - 流的长度（以字节为单位）。 - 流已关闭。 - 2 - - - 获取或设置流中的当前位置。 - 流中的当前位置。 - 此位置设置为负值或大于 的值。 - 流已关闭。 - 2 - - - 从当前流中读取字节块并将数据写入缓冲区。 - 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 - 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 - - 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 的结果小于 。 - 当前流实例已关闭。 - 2 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流中读取一个字节。 - 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 - 当前流实例已关闭。 - 2 - - - 将当前流中的位置设置为指定值。 - 流内的新位置，通过将初始引用点和偏移量合并计算而得。 - 流内的新位置。它是相对于 参数的位置，而且可正可负。 - 类型 的值，它用作查找引用点。 - 试图在流的开始位置之前查找。 - - 大于 。 - - 无效。- 或 - 导致算法溢出。 - 当前流实例已关闭。 - 2 - - - 将当前流的长度设为指定值。 - 用于设置长度的值。 - 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 - - 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 - 2 - - - 将流内容写入字节数组，而与 属性无关。 - 新的字节数组。 - 2 - - - 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 - 如果转换成功，则为 true；否则为 false。 - 用于创建此流的字节数组段。 - - - 使用从缓冲区读取的数据将字节块写入当前流。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 最多写入的字节数。 - - 为 null。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 - 缓冲区长度减去 的结果小于 。 - - 或 为负。 - 发生 I/O 错误。 - 当前流实例已关闭。 - 2 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入当前位置上的当前流。 - 要写入的字节。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 - 当前流已关闭。 - 2 - - - 将此内存流的整个内容写入到另一个流中。 - 要写入此内存流的流。 - - 为 null。 - 当前流或目标流已关闭。 - 2 - - - 指定在流的位置以查找使用。 - 2 - - - 指定流的开头。 - - - 指定流内的当前位置。 - - - 指定流的结尾。 - - - 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 类的新实例。 - - - 当在派生类中重写时，获取指示当前流是否支持读取的值。 - 如果流支持读取，为 true；否则为 false。 - 1 - - - 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 - 如果流支持查找，为 true；否则为 false。 - 1 - - - 获取一个值，该值确定当前流是否可以超时。 - 一个确定当前流是否可以超时的值。 - 2 - - - 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 - 如果流支持写入，则为 true；否则为 false。 - 1 - - - 从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - 缓冲区的大小。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放由 使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 - 发生 I/O 错误。 - 2 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。默认值为 。 - 流已被释放。 - - - 当在派生类中重写时，获取流长度（以字节为单位）。 - 表示流长度（以字节为单位）的长值。 - 从 Stream 派生的类不支持查找。 - 在流关闭后调用方法。 - 1 - - - 无后备存储区的 Stream。 - 1 - - - 当在派生类中重写时，获取或设置当前流中的位置。 - 流中的当前位置。 - 发生 I/O 错误。 - 流不支持查找。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 - 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 - 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 - - 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 - 要从当前流中最多读取的字节数。 - - 与 的和大于缓冲区长度。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流不支持读取。 - 在流关闭后调用方法。 - 1 - - - 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 - 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 - 流不支持读取。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 - 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 当在派生类中重写时，设置当前流中的位置。 - 当前流中的新位置。 - 相对于 参数的字节偏移量。 - - 类型的值，指示用于获取新位置的参考点。 - 发生 I/O 错误。 - 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，设置当前流的长度。 - 所需的当前流的长度（以字节表示）。 - 发生 I/O 错误。 - 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 2 - - - 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 - 字节数组。此方法将 个字节从 复制到当前流。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 要写入当前流的字节数。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 流不支持写入。 - - 流关闭后调用。 - 1 - - - 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 - 要写入流中的字节。 - 发生 I/O 错误。 - 该流不支持写入，或者该流已关闭。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 - 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 为指定的流初始化 类的新实例。 - 要读取的流。 - - 不支持读取。 - - 为 null。 - - - 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 - 要读取的流。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 为 null。 - - - 用指定的字符编码为指定的流初始化 类的一个新实例。 - 要读取的流。 - 要使用的字符编码。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - 最小缓冲区大小。 - 流不支持读取。 - - 或 为 null。 - - 小于或等于零。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 - 要读取的流。 - 要使用的字符编码。 - 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 - 最小缓冲区大小。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - - - 返回基础流。 - 基础流。 - 2 - - - 获取当前 对象正在使用的当前字符编码。 - 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 - 2 - - - 清除内部缓冲区。 - 2 - - - 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 获取一个值，该值指示当前的流位置是否在流结尾。 - 如果当前流位置位于流的末尾，则为 true；否则为 false。 - 基础流已释放。 - 1 - - - 空流周围的 。 - 1 - - - 返回下一个可用字符，但不使用它。 - 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 - 发生 I/O 错误。 - 1 - - - 读取输入流中的下一个字符并使该字符位置提升一个字符。 - 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 - 发生 I/O 错误。 - 1 - - - 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 - 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 开始写入的 的索引。 - 要读取的最大字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 出现 I/O 错误，如流被关闭。 - 1 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生了 I/O 错误。 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取一行字符并将数据作为字符串返回。 - 输入流中的下一行；如果到达了输入流的末尾，则为 null。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 从当前流中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 - 下一行中的字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取来自流的当前位置到结尾的所有字符。 - 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 - 字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 - 1 - - - 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 - 要写入的流。 - - 不可写。 - - 为 null。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - - 或 为 null。 - - 不可写。 - - - 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - true to leave the stream open after the object is disposed; otherwise, false. - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 - 强制 刷新其缓冲区时，为 true；否则，为 false。 - 1 - - - 获取同后备存储连接的基础流。 - 此 StreamWriter 正在写入的基础流。 - 2 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - 当前编码不支持显示半个 Unicode 代理项对。 - - - 获取将输出写入到其中的 。 - 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 - 2 - - - 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 - 当前编写器已关闭。 - 出现 I/O 错误。 - 当前编码不支持显示半个 Unicode 代理项对。 - 1 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将字符写入流。 - 要写入流中的字符。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符数组写入流。 - 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符的子数组写入流。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符串写入流。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 发生 I/O 错误。 - 1 - - - 将字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将行终止符异步写入该流。 - 表示异步写操作的任务。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 实现从字符串进行读取的 。 - 2 - - - 初始化从指定字符串进行读取的 类的新实例。 - 应将 初始化为的字符串。 - - 参数为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 返回下一个可用的字符，但不使用它。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 - 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的字符块，并将字符位置提升 。 - 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 缓存区中的起始索引。 - 要读取的字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 当前读取器已关闭。 - 2 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前字符串中读取一行字符并将数据作为字符串返回。 - 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 - 当前读取器已关闭。 - 内存不足，无法为返回的字符串分配缓冲区。 - 2 - - - 从当前字符串中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 从当前位置到基础字符串的结尾之间的内容。 - 内存不足，无法为返回的字符串分配缓冲区。 - 当前读取器已关闭。 - 2 - - - 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 - 字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式控制初始化 类的新实例。 - 控制格式设置的 对象。 - - - 初始化写入指定 的 类的新实例。 - 要写入的 StringBuilder。 - - 为 null。 - - - 初始化写入指定 并具有指定格式提供程序的 类的新实例。 - 要写入的 StringBuilder。 - 控制格式设置的 对象。 - - 为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 获取将输出写入到其中的 。 - 用来写入输出的 Encoding。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - - - 返回基础 。 - 基础 StringBuilder。 - 2 - - - 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 - 包含写入到当前 StringWriter 中的字符的字符串。 - 2 - - - 将字符写入该字符串。 - 要写入的字符。 - 编写器已关闭。 - 2 - - - 将字符的子数组写入该字符串。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - 或 为负。 - ( + )> 。Length. - 编写器已关闭。 - 2 - - - 将字符串写入当前流。 - 要写入的字符串。 - 编写器已关闭。 - 2 - - - 以异步方式将字符写入流。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将字符串写入当前流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将后跟行结束符的字符写入该字符串。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将一后跟行结束符的字符串异步写入当前字符串。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 表示可读取有序字符系列的读取器。 - 2 - - - 初始化 类的新实例。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - 提供一个无数据可供读取的 TextReader。 - 1 - - - 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 - 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 - 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 2 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从文本读取器中读取一行字符并将数据作为字符串返回。 - 读取器中的下一行，或为 null （如果已读取了所有字符）。 - 发生 I/O 错误。 - 内存不足，无法为返回的字符串分配缓冲区。 - - 是关闭的。 - 下一行中的字符数大于 - 1 - - - 异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 - 发生 I/O 错误。 - - 是关闭的。 - 内存不足，无法为返回的字符串分配缓冲区。 - 下一行中的字符数大于 - 1 - - - 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 - 字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 表示可以编写一个有序字符系列的编写器。此类为抽象类。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式提供程序初始化 类的新实例。 - 控制格式设置的 对象。 - - - 存储用于此 TextWriter 的换行符。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，返回用来写输出的该字符编码。 - 用来写入输出的字符编码。 - 1 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - 文本编写器已被释放。 - 编写器正在由其前一次写操作使用。 - - - 获取控制格式设置的对象。 - 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 - 2 - - - 获取或设置由当前 TextWriter 使用的行结束符字符串。 - 当前 TextWriter 的行结束符字符串。 - 2 - - - 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符写入该文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符数组写入该文本字符串或流。 - 要写入文本流中的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符的子数组写入文本字符串或流。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符串写入到文本字符串或流。 - 要写入的字符串。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - - 或 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符写入到下一个文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符数组写入到下一个字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符串写入到下一字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将行结束符的字符串写入文本字符串或流。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符写入文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符数组写入文本字符串或流。 - 从其读取数据的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符子数组写入文本字符串或流。 - 从其读取数据的字符数组。 - 在开始读取数据时 中的字符位置。 - 要写入的最大字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符串写入文本字符串或流。 - 要写入的字符串。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - 字符串或对象作为 null 传入。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml deleted file mode 100644 index 26192a9d..00000000 --- a/packages/System.IO.4.1.0/ref/netcore50/zh-hant/System.IO.xml +++ /dev/null @@ -1,2246 +0,0 @@ - - - - System.IO - - - - 以特定的編碼方式，將基本資料型別當做二進位值讀取。 - 2 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸入資料流。 - 資料流不支援讀取，為 null，或已經關閉。 - - - 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 - 輸入資料流。 - 要使用的字元編碼。 - 資料流不支援讀取，為 null，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 - 輸入資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - 資料流不支援讀取，為 null，或已經關閉。 - - 或 為 null。 - - - 公開 之基礎資料流的存取。 - 與 BinaryReader 相關聯的基礎資料流。 - 2 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 將從資料流讀取的指定位元組數目填入內部緩衝區。 - 要讀取的位元組數。 - 在 可讀取之前到達資料流末端。 - 發生 I/O 錯誤。 - 所要求的 大於內部緩衝區大小。 - - - 傳回下一個可用字元，而不前移位元組或字元的位置。 - 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 - 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 - 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的位元組數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 由字元陣列中的指定點開始，從資料流讀取指定字元數。 - 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的字元數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以壓縮格式讀取 32 位元整數。 - 壓縮格式的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 資料流已損毀。 - - - 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 - 如果位元組為非零值，則為 true；否則為 false。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 - 自目前資料流讀取的下一個位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 - 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 - 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為負值。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 - 自目前資料流讀取的字元。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 讀取到 Surrogate 字元 - 2 - - - 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 - 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 - 要讀取的字元數。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 已關閉資料流。 - 發生 I/O 錯誤。 - - 為負值。 - 2 - - - 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 - 自目前資料流讀取的十進位值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自目前資料流讀取的 2 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 - 自資料流讀取的帶正負號的位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 - 讀取的字串。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自這個資料流讀取 2 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自這個資料流讀取 4 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自這個資料流讀取 8 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 - 2 - - - 初始化 類別的新執行個體，其將寫入資料流。 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 資料流不支援寫入，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 要使用的字元編碼。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 輸出資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 取得 的基礎資料流。 - 與 BinaryWriter 相關聯的基礎資料流。 - 1 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 指定沒有備份存放區的 。 - 1 - - - 容納基礎資料流。 - - - 設定目前資料流位置。 - 目前資料流的位置。 - 相對於 的位元組位移。 - - 的欄位，表示要取得新位置的參考點。 - 檔案指標已移至無效的位置。 - - 值是無效的。 - 1 - - - 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 - 要寫入的 Boolean 值 (0 或 1)。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的不帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將位元組陣列寫入基礎資料流。 - 含有要寫入之資料的位元組陣列。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為 null。 - 1 - - - 將一個區域的位元組陣列寫入目前資料流。 - 含有要寫入之資料的位元組陣列。 - - 中要開始寫入的起始點。 - 要寫入的位元組數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 非 Surrogate，要寫入的 Unicode 字元。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 是單一 Surrogate 字元。 - 1 - - - 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 為 null。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 中要開始寫入的起始點。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 - 要寫入的十進位值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 要寫入的值。 - 發生 I/O 錯誤。 - - 為 null。 - 已關閉資料流。 - 1 - - - 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組不帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 以壓縮格式寫入 32 位元整數。 - 要寫入的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 已關閉資料流。 - - - 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 - 2 - - - 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - - - 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - - - 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 資料流在格式無效時擲回的例外狀況。 - - - 初始化 類別的新執行個體。 - - - 使用指定的錯誤訊息，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - - - 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 - - - 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 - 用於建立目前資料流之不帶正負號位元組的陣列。 - - 為 null。 - - - 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - - 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 為 null。 - - 或 小於零。 - 緩衝區長度減去 小於 。 - - - 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 - 內部陣列的初始大小，以位元組為單位。 - - 為負值。 - - - 取得表示目前資料流是否支援讀取的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援搜尋的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援寫入的值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 2 - - - 取得或設定配置給這個資料流的位元組數目。 - 資料流緩衝區可使用部分的長度。 - 設定的容量為負數或小於資料流目前的長度。 - 目前的資料流已經關閉。 - set 在無法修改其容量的資料流上被叫用 (Invoke)。 - 2 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 - 用來監視是否有取消要求的語彙基元。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 覆寫 方法，以便不執行任何動作。 - 2 - - - 非同步清除這個資料流的所有緩衝區，並監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。 - 已處置資料流。 - - - 取得資料流的長度，以位元組為單位。 - 資料流的長度，以位元組為單位。 - 已關閉資料流。 - 2 - - - 取得或設定資料流中目前的位置。 - 在資料流的目前位置。 - 位置設為負數值或大於 的值。 - 已關閉資料流。 - 2 - - - 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 - 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 - - 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - 緩衝區的長度減去 小於 。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從目前的資料流讀取位元組。 - 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流中的位置設定為指定的數值。 - 資料流中的新位置，是組合初始的參考點和位移計算出來的。 - 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 - - 類型的值，做為搜尋參考點。 - 在資料流開頭之前嘗試搜尋。 - - 大於 。 - 有無效的 。-或- 造成了算術溢位。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流的長度設定為指定的數值。 - 要設定長度的數值。 - 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 - - 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 - 2 - - - 不論 屬性為何，將資料流內容寫入位元組陣列。 - 新的位元組陣列。 - 2 - - - 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 - 如果轉換成功，則為 true；否則為 false。 - 從其中建立此資料流的位元組陣列區段。 - - - 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入的最大位元組數。 - - 為 null。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 - 緩衝區的長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入位元組至資料流目前位置。 - 要寫入的位元組。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 - 目前的資料流已經關閉。 - 2 - - - 將這個記憶體資料流的整個內容寫入另一個資料流。 - 要寫入這個記憶體資料流的資料流。 - - 為 null。 - 目前的資料流或目標資料流已經關閉。 - 2 - - - 指定資料流中要用於搜尋的位置。 - 2 - - - 指定資料流的開端。 - - - 指定資料流中的目前位置。 - - - 指定資料流的末端。 - - - 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 類別的新執行個體。 - - - 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 - 如果資料流支援讀取，則為 true；否則為 false。 - 1 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 - 如果資料流支援搜尋，則為 true；否則為 false。 - 1 - - - 取得值，該值判斷目前的資料流是否可以逾時。 - 值，判斷目前的資料流是否可以逾時。 - 2 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 1 - - - 從目前資料流讀取位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 所使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 發生 I/O 錯誤。 - 2 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 已處置資料流。 - - - 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - 已處置資料流。 - - - 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 - 代表資料流長度的長數值 (以位元組為單位)。 - 衍生自 Stream 的類別不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 沒有底層存放區的 Stream。 - 1 - - - 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 - 在資料流的目前位置。 - 發生 I/O 錯誤。 - 資料流不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 - 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 - 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 - - 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 - 自目前資料流讀取的最大位元組數。 - - 和 的總和大於緩衝區的長度。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 - 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - - 方法必須擲回 。 - 2 - - - 在衍生類別中覆寫時，設定在目前資料流的位置。 - 目前資料流的新位置。 - 相對於 參數的位元組位移。 - - 類型的值，表示用來取得新位置的參考點。 - 發生 I/O 錯誤。 - 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 在衍生類別中覆寫時，設定目前資料流的長度。 - 想要的目前資料流長度 (單位為位元組)。 - 發生 I/O 錯誤。 - 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 - 位元組陣列。此方法會從 複製 位元組到目前資料流。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入目前資料流的位元組數目。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 資料流不支援寫入。 - - 流关闭后调用。 - 1 - - - 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 - 寫入資料流的位元組。 - 發生 I/O 錯誤。 - 資料流不支援寫入，或資料流已經關閉。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - - 方法必須擲回 。 - 2 - - - 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 為指定的資料流，初始化 類別的新執行個體。 - 要讀取的資料流。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - 最小緩衝區大小。 - 資料流不支援讀取。 - - 或 為 null。 - - 小於或等於零值。 - - - 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要讀取的資料流。 - 要使用的字元編碼。 - true 表示在檔案開頭尋找位元順序標記；否則為 false。 - 最小緩衝區大小。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - - - 傳回基礎資料流。 - 基礎資料流。 - 2 - - - 取得目前 物件使用的目前字元編碼。 - 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 - 2 - - - 清除內部緩衝區。 - 2 - - - 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得表示現行資料流位置是否在資料流結尾的值。 - 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 - 已處置基礎資料流。 - 1 - - - 空資料流周圍的 物件。 - 1 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 1 - - - 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 - 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 - 發生 I/O 錯誤。 - 1 - - - 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 - 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - 要開始寫入的 的索引。 - 要讀取的字元數上限。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤，例如資料流已經關閉。 - 1 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前資料流讀取一行字元，並將資料以字串傳回。 - 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 - 下一行中的字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到資料流末端的所有字元。 - 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 - 字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 - 1 - - - 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - - 不可寫入。 - - 為 null。 - - - 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - - 或 是 null。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 - 強制 清除其緩衝區，則為 true，否則為 false。 - 1 - - - 取得以備份存放區作介面的基礎資料流。 - StreamWriter 正在寫入的資料流。 - 2 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - - - 取得寫入輸出的 。 - - (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 - 2 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 - 目前寫入器已關閉。 - 發生 I/O 錯誤。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - 1 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - 已處置資料流。 - - - 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將一個字元寫入資料流。 - 要寫入資料流的字元。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元陣列寫入資料流。 - 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元子陣列寫入資料流。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字串寫入資料流。 - 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入資料流。 - 表示非同步寫入作業的工作。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 將行結束字元以非同步方式寫入資料流。 - 表示非同步寫入作業的工作。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 實作讀取字串的 。 - 2 - - - 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 - - 應該初始化的目的字串。 - - 參數為 null。 - - - 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 - 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 - 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - 緩衝區中的起始索引。 - 要讀取的字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負數。 - 目前的讀取器已關閉。 - 2 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前字串讀取一行字元，並將資料以字串傳回。 - 目前字串的下一行，如果已到達字串的結尾，則為 null。 - 目前的讀取器已關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 2 - - - 自目前字串非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 基礎字串從目前位置至結尾的內容。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 目前的讀取器已關閉。 - 2 - - - 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 - 字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的控制項格式，初始化 類別的新執行個體。 - 控制格式的 物件。 - - - 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 - 要寫入至其中的 StringBuilder。 - - 為 null。 - - - 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 - 要寫入至其中的 StringBuilder。 - 控制格式的 物件。 - - 為 null。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得寫入輸出的 。 - 寫入輸出的 Encoding。 - 1 - - - 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - - - 傳回基礎 。 - 基礎 StringBuilder。 - 2 - - - 傳回字串，包含被寫入至目前 StringWriter 的字元。 - 字串，包含被寫入至目前 StringWriter 的字元。 - 2 - - - 將一個字元寫入至字串。 - 要寫入的字元。 - 寫入器關閉。 - 2 - - - 將字元子陣列寫入至字串。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 或 為負數。 - ( + )> 。Length. - 寫入器關閉。 - 2 - - - 將字串寫入至目前字串。 - 要寫入的字串。 - 寫入器關閉。 - 2 - - - 以非同步方式將字元寫入至字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入至字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入至目前字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 代表可以讀取一連串連續字元的讀取器 (Reader)。 - 2 - - - 初始化 類別的新執行個體。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 提供未讀取資料的 TextReader。 - 1 - - - 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 - 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 2 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自文字讀取器讀取一行字元，並將資料以字串傳回。 - 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 - 發生 I/O 錯誤。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - - 已經關閉。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 字串，包含從目前位置到文字讀取器結尾的所有字元。 - 發生 I/O 錯誤。 - - 已經關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 - 字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的格式提供者，初始化 類別的新執行個體。 - 控制格式設定的 物件。 - - - 儲存這個 TextWriter 所使用的新行字元。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 - 寫入輸出時使用的字元編碼。 - 1 - - - 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 文字寫入器已處置。 - 寫入器目前由先前寫入作業所使用。 - - - 取得控制格式設定的物件。 - 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 - 2 - - - 取得或設定目前 TextWriter 所使用的行結束字元字串。 - 目前 TextWriter 的行結束字元字串。 - 2 - - - 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將 Boolean 值的文字表示寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列寫入到文字字串或資料流。 - 要寫入到文字資料流的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元的子陣列寫入到文字字串或資料流。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 - 要寫入的物件。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串寫入到文字字串或資料流。 - 要寫入的字串。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - - 或 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 將行結束字元寫入到文字字串或資料流。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 中開始讀取資料的字元位置。 - 要寫入的最大字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的物件。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入的字串。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - 傳入的字串或物件為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將行結束字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.dll deleted file mode 100644 index 97702f121c6806139303d133453c27092e47e89c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 30128 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 ATmS$7 diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml deleted file mode 100644 index 94677abb..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Reads primitive data types as binary values in a specific encoding. - 2 - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The input stream. - The stream does not support reading, is null, or is already closed. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The input stream. - The character encoding to use. - The stream does not support reading, is null, or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The input stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support reading, is null, or is already closed. - - or is null. - - - Exposes access to the underlying stream of the . - The underlying stream associated with the BinaryReader. - 2 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Fills the internal buffer with the specified number of bytes read from the stream. - The number of bytes to be read. - The end of the stream is reached before could be read. - An I/O error occurs. - Requested is larger than the internal buffer size. - - - Returns the next available character and does not advance the byte or character position. - The next available character, or -1 if no more characters are available or the stream does not support seeking. - An I/O error occurs. - The current character cannot be decoded into the internal character buffer by using the selected for the stream. - 2 - - - Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - The next character from the input stream, or -1 if no characters are currently available. - An I/O error occurs. - The stream is closed. - 2 - - - Reads the specified number of bytes from the stream, starting from a specified point in the byte array. - The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of bytes to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of characters from the stream, starting from a specified point in the character array. - The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of characters to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads in a 32-bit integer in compressed format. - A 32-bit integer in compressed format. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - The stream is corrupted. - - - Reads a Boolean value from the current stream and advances the current position of the stream by one byte. - true if the byte is nonzero; otherwise, false. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the next byte from the current stream and advances the current position of the stream by one byte. - The next byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. - A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. - The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - An I/O error occurs. - The stream is closed. - - is negative. - 2 - - - Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - A character read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - A surrogate character was read. - 2 - - - Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. - A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. - The number of characters to read. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - The stream is closed. - An I/O error occurs. - - is negative. - 2 - - - Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. - A decimal value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. - An 8-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. - A 2-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. - A 4-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. - An 8-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a signed byte from this stream and advances the current position of the stream by one byte. - A signed byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. - A 4-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. - The string being read. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. - A 2-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. - A 4-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. - An 8-byte unsigned integer read from this stream. - The end of the stream is reached. - An I/O error occurs. - The stream is closed. - 2 - - - Writes primitive types in binary to a stream and supports writing strings in a specific encoding. - 2 - - - Initializes a new instance of the class that writes to a stream. - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The output stream. - The stream does not support writing or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The output stream. - The character encoding to use. - The stream does not support writing or is already closed. - - or is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The output stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support writing or is already closed. - - or is null. - - - Gets the underlying stream of the . - The underlying stream associated with the BinaryWriter. - 1 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Specifies a with no backing store. - 1 - - - Holds the underlying stream. - - - Sets the position within the current stream. - The position with the current stream. - A byte offset relative to . - A field of indicating the reference point from which the new position is to be obtained. - The file pointer was moved to an invalid location. - The value is invalid. - 1 - - - Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. - The Boolean value to write (0 or 1). - An I/O error occurs. - The stream is closed. - 1 - - - Writes an unsigned byte to the current stream and advances the stream position by one byte. - The unsigned byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a byte array to the underlying stream. - A byte array containing the data to write. - An I/O error occurs. - The stream is closed. - - is null. - 1 - - - Writes a region of a byte array to the current stream. - A byte array containing the data to write. - The starting point in at which to begin writing. - The number of bytes to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - The non-surrogate, Unicode character to write. - An I/O error occurs. - The stream is closed. - - is a single surrogate character. - 1 - - - Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - A character array containing the data to write. - - is null. - The stream is closed. - An I/O error occurs. - 1 - - - Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. - A character array containing the data to write. - The starting point in from which to begin writing. - The number of characters to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a decimal value to the current stream and advances the stream position by sixteen bytes. - The decimal value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. - The eight-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. - The two-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. - The four-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. - The eight-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a signed byte to the current stream and advances the stream position by one byte. - The signed byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. - The four-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. - The value to write. - An I/O error occurs. - - is null. - The stream is closed. - 1 - - - Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. - The two-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. - The four-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. - The eight-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a 32-bit integer in a compressed format. - The 32-bit integer to be written. - The end of the stream is reached. - The stream is closed. - The stream is closed. - - - The exception that is thrown when reading is attempted past the end of a stream. - 2 - - - Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. - - - Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - - - Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - The exception that is thrown when a data stream is in an invalid format. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with a specified error message. - The error message that explains the reason for the exception. - - - Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. - The error message that explains the reason for the exception. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class with an expandable capacity initialized to zero. - - - Initializes a new non-resizable instance of the class based on the specified byte array. - The array of unsigned bytes from which to create the current stream. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. - The array of unsigned bytes from which to create this stream. - The setting of the property, which determines whether the stream supports writing. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - - is null. - - or is less than zero. - The buffer length minus is less than . - - - Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. - The array of unsigned bytes from which to create this stream. - The index in at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - - is null. - - or are negative. - The buffer length minus is less than . - - - Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. - - is null. - - or is negative. - The buffer length minus is less than . - - - Initializes a new instance of the class with an expandable capacity initialized as specified. - The initial size of the internal array in bytes. - - is negative. - - - Gets a value indicating whether the current stream supports reading. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports seeking. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 2 - - - Gets or sets the number of bytes allocated for this stream. - The length of the usable portion of the buffer for the stream. - A capacity is set that is negative or less than the current length of the stream. - The current stream is closed. - set is invoked on a stream whose capacity cannot be modified. - 2 - - - Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. - The token to monitor for cancellation requests. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Overrides the method so that no action is performed. - 2 - - - Asynchronously clears all buffers for this stream, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. - The stream has been disposed. - - - Gets the length of the stream in bytes. - The length of the stream in bytes. - The stream is closed. - 2 - - - Gets or sets the current position within the stream. - The current position within the stream. - The position is set to a negative value or a value greater than . - The stream is closed. - 2 - - - Reads a block of bytes from the current stream and writes the data to a buffer. - The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. - When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. - The zero-based byte offset in at which to begin storing data from the current stream. - The maximum number of bytes to read. - - is null. - - or is negative. - - subtracted from the buffer length is less than . - The current stream instance is closed. - 2 - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the current stream. - The byte cast to a , or -1 if the end of the stream has been reached. - The current stream instance is closed. - 2 - - - Sets the position within the current stream to the specified value. - The new position within the stream, calculated by combining the initial reference point and the offset. - The new position within the stream. This is relative to the parameter, and can be positive or negative. - A value of type , which acts as the seek reference point. - Seeking is attempted before the beginning of the stream. - - is greater than . - There is an invalid . -or- caused an arithmetic overflow. - The current stream instance is closed. - 2 - - - Sets the length of the current stream to the specified value. - The value at which to set the length. - The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. - - is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. - 2 - - - Writes the stream contents to a byte array, regardless of the property. - A new byte array. - 2 - - - Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. - true if the conversion was successful; otherwise, false. - The byte array segment from which this stream was created. - - - Writes a block of bytes to the current stream using data read from a buffer. - The buffer to write data from. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The maximum number of bytes to write. - - is null. - The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. - - subtracted from the buffer length is less than . - - or are negative. - An I/O error occurs. - The current stream instance is closed. - 2 - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current stream at the current position. - The byte to write. - The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. - The current stream is closed. - 2 - - - Writes the entire contents of this memory stream to another stream. - The stream to write this memory stream to. - - is null. - The current or target stream is closed. - 2 - - - Specifies the position in a stream to use for seeking. - 2 - - - Specifies the beginning of a stream. - - - Specifies the current position within a stream. - - - Specifies the end of a stream. - - - Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class. - - - When overridden in a derived class, gets a value indicating whether the current stream supports reading. - true if the stream supports reading; otherwise, false. - 1 - - - When overridden in a derived class, gets a value indicating whether the current stream supports seeking. - true if the stream supports seeking; otherwise, false. - 1 - - - Gets a value that determines whether the current stream can time out. - A value that determines whether the current stream can time out. - 2 - - - When overridden in a derived class, gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 1 - - - Reads the bytes from the current stream and writes them to another stream. - The stream to which the contents of the current stream will be copied. - - is null. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - The stream to which the contents of the current stream will be copied. - The size of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Asynchronously reads the bytes from the current stream and writes them to another stream. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - - is null. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - The token to monitor for cancellation requests. The default value is . - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases all resources used by the . - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. - An I/O error occurs. - 2 - - - Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. The default value is . - The stream has been disposed. - - - When overridden in a derived class, gets the length in bytes of the stream. - A long value representing the length of the stream in bytes. - A class derived from Stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - A Stream with no backing store. - 1 - - - When overridden in a derived class, gets or sets the position within the current stream. - The current position within the stream. - An I/O error occurs. - The stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - The sum of and is larger than the buffer length. - - is null. - - or is negative. - An I/O error occurs. - The stream does not support reading. - Methods were called after the stream was closed. - 1 - - - Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. - The unsigned byte cast to an Int32, or -1 if at the end of the stream. - The stream does not support reading. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. - A value, in miliseconds, that determines how long the stream will attempt to read before timing out. - The method always throws an . - 2 - - - When overridden in a derived class, sets the position within the current stream. - The new position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - An I/O error occurs. - The stream does not support seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - An I/O error occurs. - The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 2 - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - The sum of  and  is greater than the buffer length. - - is null. - - or  is negative. - An I/O error occured, such as the specified file cannot be found. - The stream does not support writing. - - was called after the stream was closed. - 1 - - - Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current position in the stream and advances the position within the stream by one byte. - The byte to write to the stream. - An I/O error occurs. - The stream does not support writing, or the stream is already closed. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. - A value, in miliseconds, that determines how long the stream will attempt to write before timing out. - The method always throws an . - 2 - - - Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream. - The stream to be read. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. - The stream to be read. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding. - The stream to be read. - The character encoding to use. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - The minimum buffer size. - The stream does not support reading. - - or is null. - - is less than or equal to zero. - - - Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. - The stream to read. - The character encoding to use. - true to look for byte order marks at the beginning of the file; otherwise, false. - The minimum buffer size. - true to leave the stream open after the object is disposed; otherwise, false. - - - Returns the underlying stream. - The underlying stream. - 2 - - - Gets the current character encoding that the current object is using. - The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. - 2 - - - Clears the internal buffer. - 2 - - - Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets a value that indicates whether the current stream position is at the end of the stream. - true if the current stream position is at the end of the stream; otherwise false. - The underlying stream has been disposed. - 1 - - - A object around an empty stream. - 1 - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. - An I/O error occurs. - 1 - - - Reads the next character from the input stream and advances the character position by one character. - The next character from the input stream represented as an object, or -1 if no more characters are available. - An I/O error occurs. - 1 - - - Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. - The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The index of at which to begin writing. - The maximum number of characters to read. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs, such as the stream is closed. - 1 - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurred. - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current stream and returns the data as a string. - The next line from the input stream, or null if the end of the input stream is reached. - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads a line of characters asynchronously from the current stream and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the stream. - The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. - The number of characters is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. - The stream to write to. - - is not writable. - - is null. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. - The stream to write to. - The character encoding to use. - - or is null. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - - or is null. - - is negative. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - true to leave the stream open after the object is disposed; otherwise, false. - - or is null. - - is negative. - - is not writable. - - - Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . - true to force to flush its buffer; otherwise, false. - 1 - - - Gets the underlying stream that interfaces with a backing store. - The stream this StreamWriter is writing to. - 2 - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - The current encoding does not support displaying half of a Unicode surrogate pair. - - - Gets the in which the output is written. - The specified in the constructor for the current instance, or if an encoding was not specified. - 2 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. - The current writer is closed. - An I/O error has occurred. - The current encoding does not support displaying half of a Unicode surrogate pair. - 1 - - - Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Provides a StreamWriter with no backing store that can be written to, but not read from. - 1 - - - Writes a character to the stream. - The character to write to the stream. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a character array to the stream. - A character array containing the data to write. If is null, nothing is written. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a subarray of characters to the stream. - A character array that contains the data to write. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The buffer length minus is less than . - - or is negative. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a string to the stream. - The string to write to the stream. If is null, nothing is written. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - An I/O error occurs. - 1 - - - Writes a character to the stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the stream asynchronously. - A task that represents the asynchronous write operation. - A character array that contains the data to write. - The character position in the buffer at which to begin reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string to the stream asynchronously. - A task that represents the asynchronous write operation. - The string to write to the stream. If is null, nothing is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Implements a that reads from a string. - 2 - - - Initializes a new instance of the class that reads from the specified string. - The string to which the should be initialized. - The parameter is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. - The current reader is closed. - 2 - - - Reads the next character from the input string and advances the character position by one character. - The next character from the underlying string, or -1 if no more characters are available. - The current reader is closed. - 2 - - - Reads a block of characters from the input string and advances the character position by . - The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The starting index in the buffer. - The number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The current reader is closed. - 2 - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current string and returns the data as a string. - The next line from the current string, or null if the end of the string is reached. - The current reader is closed. - There is insufficient memory to allocate a buffer for the returned string. - 2 - - - Reads a line of characters asynchronously from the current string and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the string and returns them as a single string. - The content from the current position to the end of the underlying string. - There is insufficient memory to allocate a buffer for the returned string. - The current reader is closed. - 2 - - - Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. - The number of characters is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing information to a string. The information is stored in an underlying . - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format control. - An object that controls formatting. - - - Initializes a new instance of the class that writes to the specified . - The StringBuilder to write to. - - is null. - - - Initializes a new instance of the class that writes to the specified and has the specified format provider. - The StringBuilder to write to. - An object that controls formatting. - - is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets the in which the output is written. - The Encoding in which the output is written. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - - - Returns the underlying . - The underlying StringBuilder. - 2 - - - Returns a string containing the characters written to the current StringWriter so far. - The string containing the characters written to the current StringWriter. - 2 - - - Writes a character to the string. - The character to write. - The writer is closed. - 2 - - - Writes a subarray of characters to the string. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - - or is negative. - ( + )> . Length. - The writer is closed. - 2 - - - Writes a string to the current string. - The string to write. - The writer is closed. - 2 - - - Writes a character to the string asynchronously. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the string asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string to the current string asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the current string. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Represents a reader that can read a sequential series of characters. - 2 - - - Initializes a new instance of the class. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Provides a TextReader with no data to read from. - 1 - - - Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. - An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. - The is closed. - An I/O error occurs. - 1 - - - Reads the next character from the text reader and advances the character position by one character. - The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 2 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the text reader and returns the data as a string. - The next line from the reader, or null if all characters have been read. - An I/O error occurs. - There is insufficient memory to allocate a buffer for the returned string. - The is closed. - The number of characters in the next line is larger than - 1 - - - Reads a line of characters asynchronously and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. - The number of characters in the next line is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the text reader and returns them as one string. - A string that contains all characters from the current position to the end of the text reader. - An I/O error occurs. - The is closed. - There is insufficient memory to allocate a buffer for the returned string. - The number of characters in the next line is larger than - 1 - - - Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. - The number of characters is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Represents a writer that can write a sequential series of characters. This class is abstract. - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format provider. - An object that controls formatting. - - - Stores the newline characters used for this TextWriter. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, returns the character encoding in which the output is written. - The character encoding in which the output is written. - 1 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The text writer is disposed. - The writer is currently in use by a previous write operation. - - - Gets an object that controls formatting. - An object for a specific culture, or the formatting of the current culture if no other culture is specified. - 2 - - - Gets or sets the line terminator string used by the current TextWriter. - The line terminator string for the current TextWriter. - 2 - - - Provides a TextWriter with no backing store that can be written to, but not read from. - 1 - - - Writes the text representation of a Boolean value to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a character array to the text string or stream. - The character array to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters to the text string or stream. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte floating-point value to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object to the text string or stream by calling the ToString method on that object. - The object to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string to the text string or stream. - The string to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - - or is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character array to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If is null, nothing is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a line terminator to the text string or stream. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character followed by a line terminator to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes an array of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The character position in at which to start reading data. - The maximum number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value followed by a line terminator to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. - The object to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string followed by a line terminator to the text string or stream. - The string to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - A string or object is passed in as null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes an array of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If the character array is null, only the line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml deleted file mode 100644 index 07b2661f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/de/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. - 2 - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. - Der Eingabestream. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - oder ist null. - - - Gewährt Zugriff auf den zugrunde liegenden Stream von . - Der BinaryReader zugeordnete, zugrunde liegende Stream. - 2 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. - Die Anzahl der zu lesenden Bytes. - Das Ende des Streams ist erreicht, bevor gelesen werden konnte. - E/A-Fehler. - Die angeforderten überschreiten die interne Puffergröße. - - - Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. - Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. - 2 - - - Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. - Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Bytes. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 32-Bit-Ganzzahl in komprimiertem Format. - Eine 32-Bit-Ganzzahl in komprimiertem Format. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Der Datenstrom ist beschädigt. - - - Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - true, wenn das Byte ungleich 0 (null) ist, andernfalls false. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - Das nächste aus dem aktuellen Stream gelesene Byte. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. - Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - E/A-Fehler. - Der Stream ist geschlossen. - - ist negativ. - 2 - - - Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein aus dem aktuellen Stream gelesenes Zeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Ein Ersatzzeichenzeichen wurde gelesen. - 2 - - - Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Zeichen. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - Der Stream ist geschlossen. - E/A-Fehler. - - ist negativ. - 2 - - - Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. - Ein aus dem aktuellen Stream gelesener Dezimalwert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. - Die gelesene Zeichenfolge. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. - Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. - Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. - 2 - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. - - - Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. - Der Ausgabestream. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Ruft den zugrunde liegenden Stream von ab. - Der BinaryWriter zugeordnete, zugrunde liegende Stream. - 1 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Gibt eine -Klasse ohne Sicherungsspeicher an. - 1 - - - Enthält den zugrunde liegenden Stream. - - - Legt die Position im aktuellen Stream fest. - Die Position im aktuellen Stream. - Ein Byteoffset im Verhältnis zu . - Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. - Der Dateizeiger wurde an eine ungültige Position verschoben. - Der -Wert ist ungültig. - 1 - - - Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. - Der zu schreibende Boolean-Wert (0 (null) oder 1). - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Bytearray in den zugrunde liegenden Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - E/A-Fehler. - Der Stream ist geschlossen. - - ist null. - 1 - - - Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Bytes. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). - E/A-Fehler. - Der Stream ist geschlossen. - - ist ein einzelnes Ersatzzeichen. - 1 - - - Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - - ist null. - Der Stream ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. - Der zu schreibende Dezimalwert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Der zu schreibende 8-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Der zu schreibende 4-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. - Der zu schreibende Wert. - E/A-Fehler. - - ist null. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. - Die zu schreibende 32-Bit-Ganzzahl. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - Der Stream ist geschlossen. - - - Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. - 2 - - - Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. - - - Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - - - Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. - - ist null. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - - Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - - ist null. - - oder ist kleiner als 0. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , bei dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. - Die Anfangsgröße des internen Arrays in Bytes. - - ist negativ. - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 2 - - - Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. - Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. - Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. - Der aktuelle Stream ist geschlossen. - set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. - 2 - - - Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. - Das Token zum überwachen von Abbruchanforderungen . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen . - Der Stream wurde freigegeben. - - - Ruft die Länge des Streams in Bytes ab. - Die Länge des Streams in Bytes. - Der Stream ist geschlossen. - 2 - - - Ruft die aktuelle Position im Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. - Der Stream ist geschlossen. - 2 - - - Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. - Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. - Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - - subtrahiert von der Pufferlänge ist kleiner als . - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem aktuellen Stream. - Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Position im aktuellen Stream auf den angegebenen Wert fest. - Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. - Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. - Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. - Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. - - ist größer als . - Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. - Der Wert, auf den die Länge festgelegt werden soll. - Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. - - ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. - 2 - - - Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. - Ein neues Bytearray. - 2 - - - Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. - true, wenn die Konvertierung erfolgreich war, andernfalls false. - Das Bytearraysegment, aus dem der Stream erstellt wurde. - - - Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. - - subtrahiert von der Pufferlänge ist kleiner als . - - oder ist negativ. - E/A-Fehler. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuelle Position im aktuellen Stream. - Das zu schreibende Byte. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. - Der aktuelle Stream ist geschlossen. - 2 - - - Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. - Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. - - ist null. - Der aktuelle Stream oder der Zielstream ist geschlossen. - 2 - - - Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. - 2 - - - Gibt den Anfang eines Streams an. - - - Gibt die aktuelle Position innerhalb eines Streams an. - - - Gibt das Ende eines Streams an. - - - Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. - 1 - - - Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - 2 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 1 - - - Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt alle vom verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - E/A-Fehler. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - Der Stream wurde freigegeben. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. - Ein Long-Wert, der die Länge des Streams in Bytes darstellt. - Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Ein Stream ohne Sicherungsspeicher. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. - Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. - Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. - Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. - Die Summe aus und ist größer als die Pufferlänge. - - ist null. - - oder ist negativ. - E/A-Fehler. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. - Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. - Die neue Position innerhalb des aktuellen Streams. - Ein Byteoffset relativ zum -Parameter. - Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. - Die gewünschte Länge des aktuellen Streams in Bytes. - E/A-Fehler. - Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. - Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. - Die Summe der  und  ist größer als die Länge des Puffers. - - ist null. - - oder  ist negativ. - E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. - Der Stream unterstützt das Schreiben nicht. - - wurde aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das Byte, das in den Stream geschrieben werden soll. - E/A-Fehler. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. - Der zu lesende Stream. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - Die Mindestgröße des Puffers. - Lesevorgänge werden vom Stream nicht unterstützt. - - oder ist null. - - ist kleiner oder gleich 0 (null). - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. - Die Mindestgröße des Puffers. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - - Gibt den zugrunde liegenden Stream zurück. - Der zugrunde liegende Stream. - 2 - - - Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. - Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. - 2 - - - Löscht den internen Puffer. - 2 - - - Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. - true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. - Der zugrunde liegende Stream wurde verworfen. - 1 - - - Ein -Objekt um einen leeren Stream. - 1 - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. - E/A-Fehler. - 1 - - - Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. - Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Index von , bei dem mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - Ein E/A-Fehler ist aufgetreten. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. - Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. - Die Anzahl der Zeichen ist niedriger als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - - ist schreibgeschützt. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - - oder ist null. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. - true, um zum Entleeren des Puffers zu zwingen, andernfalls false. - 1 - - - Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. - Der Stream, in den dieser StreamWriter schreibt. - 2 - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. - 2 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. - Der aktuelle Writer wird geschlossen. - Ein E/A-Fehler ist aufgetreten. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - 1 - - - Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt ein Zeichen in den Stream. - Das in den Stream zu schreibende Zeichen. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Zeichenarray in den Stream. - Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Teilarray von Zeichen in den Stream. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt eine Zeichenfolge in den Stream. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Implementiert einen , der aus einer Zeichenfolge liest. - 2 - - - Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. - Die Zeichenfolge, mit der der initialisiert werden soll. - Der -Parameter ist null. - - - Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Anfangsindex im Puffer. - Die Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. - Der aktuelle Reader ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - 2 - - - Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. - Die Anzahl der Zeichen ist niedriger als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. - Ein -Objekt zum Steuern der Formatierung. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . - Der StringBuilder, in den geschrieben werden soll. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. - Der StringBuilder, in den geschrieben werden soll. - Ein -Objekt zum Steuern der Formatierung. - - ist null. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die Encoding, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - - - Gibt den zugrunde liegenden zurück. - Der zugrunde liegende StringBuilder. - 2 - - - Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - 2 - - - Schreibt ein Zeichen in die Zeichenfolge. - Das zu schreibende Zeichen. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Teilarray von Zeichen in die Zeichenfolge. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - - oder ist negativ. - ( + )> .Length. - Der Writer ist geschlossen. - 2 - - - Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. - Die zu schreibende Zeichenfolge. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Stellt einen TextReader ohne zu lesende Daten bereit. - 1 - - - Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. - Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 2 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. - E/A-Fehler. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der ist geschlossen. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. - E/A-Fehler. - Der ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. - Die Anzahl der Zeichen ist niedriger als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. - Ein -Objekt zum Steuern der Formatierung. - - - Speichert die für diesen TextWriter verwendeten Zeilenendemarken. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. - Die Zeichencodierung, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Textwriter wird freigegeben. - Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Ruft ein Objekt zum Steuern der Formatierung ab. - Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. - 2 - - - Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. - Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. - 2 - - - Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichenarray. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. - Das zu schreibende Objekt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - - oder ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - Eine Zeichenfolge oder ein Objekt wird als null übergeben. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml deleted file mode 100644 index 0b2c206b..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/es/System.IO.xml +++ /dev/null @@ -1,2090 +0,0 @@ - - - - System.IO - - - - Lee tipos de datos primitivos como valores binarios en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. - La secuencia de entrada. - La secuencia no admite la lectura, es null, o ya está cerrada. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de o es null. - - - Expone el acceso a la secuencia subyacente de . - Secuencia subyacente asociada a BinaryReader. - 2 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. - Número de bytes que se va a leer. - Se llega al final de la secuencia antes de se ha podido leer. - Se produce un error de E/S. - Solicitado es mayor que el tamaño del búfer interno. - - - Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. - Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. - 2 - - - Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. - Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. - Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de bytes que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. - Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de caracteres que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero de 32 bits en formato comprimido. - Entero de 32 bits en formato comprimido. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - La secuencia está dañada. - - - Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Es true si el byte es distinto de cero; en caso contrario, es false. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Siguiente byte que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. - Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. - Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - Se produce un error de E/S. - La secuencia está cerrada. - - es negativo. - 2 - - - Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. - Carácter que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - Se ha leído un carácter suplente. - 2 - - - Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. - Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. - Número de caracteres que se va a leer. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - La secuencia está cerrada. - Se produce un error de E/S. - - es negativo. - 2 - - - Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. - Valor decimal que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. - Valor de punto flotante de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. - Entero con signo de 2 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Entero con signo de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. - Entero con signo de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. - Byte con signo que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Valor de punto flotante de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. - Cadena que se lee. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. - Entero sin signo de 2 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. - Entero sin signo de 4 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. - Entero sin signo de 8 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase que escribe en una secuencia. - - - Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. - Flujo de salida. - La secuencia no admite escritura o ya se encuentra cerrada. - - es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - Flujo de salida. - Codificación de caracteres que se utilizará. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. - Flujo de salida. - Codificación de caracteres que se utilizará. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Obtiene la secuencia subyacente del objeto . - Flujo subyacente asociado a BinaryWriter. - 1 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Especifica un objeto sin memoria auxiliar. - 1 - - - Contiene la secuencia subyacente. - - - Establece la posición en la secuencia actual. - Posición con la secuencia actual. - Desplazamiento de bytes relacionado con . - Un campo de que indica el punto de referencia del que se obtiene la nueva posición. - El puntero de archivo se ha movido a una posición no válida. - El valor de no es válido. - 1 - - - Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. - Valor Boolean que se va a escribir (0 ó 1). - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte sin signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una matriz de bytes en la secuencia subyacente. - Matriz de bytes que contiene los datos que se van a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es null. - 1 - - - Escribe una región de una matriz de bytes en la secuencia actual. - Matriz de bytes que contiene los datos que se van a escribir. - Punto inicial de donde comenzará la escritura. - Número de bytes que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. - El carácter Unicode no suplente que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es un carácter suplente único. - 1 - - - Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - - es null. - La secuencia está cerrada. - Se produce un error de E/S. - 1 - - - Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Punto inicial de donde se empieza a leer. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. - Valor decimal que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Valor de punto flotante de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero con signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero con signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero con signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte con signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Valor de punto flotante de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. - Valor que se va a escribir. - Se produce un error de E/S. - - es null. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero sin signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero sin signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero sin signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero de 32 bits en formato comprimido. - Entero de 32 bits que se va a escribir. - Se llega al final de la secuencia. - La secuencia está cerrada. - La secuencia está cerrada. - - - Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. - 2 - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - - - Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Excepción que se inicia cuando el formato de un flujo de datos no es válido. - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el mensaje de error especificado. - Mensaje de error que explica la razón de la excepción. - - - Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. - Mensaje de error que explica la razón de la excepción. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. - - - Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. - Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - El valor de es null. - - o es menor que cero. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - o son negativos. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. - El valor de es null. - - o es negativo. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. - Tamaño inicial de la matriz interna en bytes. - - es negativo. - - - Obtiene un valor que indica si la secuencia actual admite lectura. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite búsquedas. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 2 - - - Obtiene o establece el número de bytes asignados a esta secuencia. - Longitud de la parte utilizable del búfer para la secuencia. - Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. - La secuencia actual está cerrada. - set se invoca en una secuencia cuya capacidad no se puede modificar. - 2 - - - Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero. - Token para supervisar solicitudes de cancelación. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Reemplaza el método de modo que no se realice ninguna acción. - 2 - - - De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación. - Se ha eliminado la secuencia. - - - Obtiene la longitud de la secuencia en bytes. - Longitud de la secuencia en bytes. - La secuencia está cerrada. - 2 - - - Obtiene o establece la posición actual dentro de la secuencia. - Posición actual dentro de la secuencia. - La posición se establece en un valor negativo o un valor mayor que . - La secuencia está cerrada. - 2 - - - Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. - Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. - Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. - Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - - resta de la longitud del búfer es menor que . - La instancia de la secuencia actual está cerrada. - 2 - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia actual. - El byte convertido en un o -1 si se llega al final de la secuencia. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la posición dentro de la secuencia actual en el valor especificado. - Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. - Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. - Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. - Se ha intentado realizar una búsqueda antes del inicio de la secuencia. - - es mayor que . - Hay un no válido . o bien se produjo un desbordamiento aritmético. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la longitud de la secuencia actual en el valor especificado. - Valor en el que establecer la longitud. - La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. - - es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. - 2 - - - Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . - Nueva matriz de bytes. - 2 - - - Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. - Es true si la conversión se realiza correctamente; en caso contrario, es false. - El segmento de matriz de bytes desde el que se creó esta secuencia. - - - Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número máximo de bytes que se pueden escribir. - El valor de es null. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. - - resta de la longitud del búfer es menor que . - - o son negativos. - Se produce un error de E/S. - La instancia de la secuencia actual está cerrada. - 2 - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte en la posición actual de la secuencia actual. - Byte que se va a escribir. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. - La secuencia actual está cerrada. - 2 - - - Escribe el contenido completo de esta secuencia de memoria en otra secuencia. - Secuencia en la que se va a escribir esta secuencia de memoria. - El valor de es null. - La secuencia actual o de destino está cerrada. - 2 - - - Especifica la posición usada para buscar en una secuencia. - 2 - - - Especifica el comienzo de una secuencia. - - - Especifica lo posición actual dentro de la secuencia. - - - Especifica el final de una secuencia. - - - Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase . - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. - true si la secuencia admite lectura; en caso contrario, false. - 1 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. - true si la secuencia admite búsquedas; en caso contrario, false. - 1 - - - Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - 2 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 1 - - - Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera todos los recursos usados por . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Se produce un error de E/S. - 2 - - - Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - Se ha eliminado la secuencia. - - - Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. - Un valor Long que representa la longitud de la secuencia en bytes. - Una clase derivada de Stream no admite la búsqueda. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Stream sin memoria auxiliar. - 1 - - - Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. - Posición actual dentro de la secuencia. - Se produce un error de E/S. - La secuencia no admite búsquedas. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. - Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. - Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. - Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. - Número máximo de bytes que se deben leer de la secuencia actual. - La suma de y es mayor que la longitud del búfer. - El valor de es null. - - o es negativo. - Se produce un error de E/S. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. - Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. - La nueva posición dentro de la secuencia actual. - Desplazamiento de bytes relacionado con el parámetro . - Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. - Se produce un error de E/S. - La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. - Longitud deseada de la secuencia actual, en bytes. - Se produce un error de E/S. - La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. - Matriz de bytes.Este método copia bytes desde al flujo actual. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número de bytes que se deben escribir en la secuencia actual. - La suma de  y  es mayor que la longitud del búfer. - - es null. - - o  es negativo. - Se produjo un error de E/S, como no se puede encontrar el archivo especificado. - La secuencia no es compatible con la escritura. - - se llama después de cerrar la secuencia. - 1 - - - Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. - Byte que se debe escribir en la secuencia. - Se produce un error de E/S. - La secuencia no admite escritura o ya se encuentra cerrada. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 1 - - - Inicializa una nueva instancia de la clase para el flujo especificado. - Secuencia que se va a leer. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - Tamaño mínimo de búfer. - La secuencia no admite lectura. - El valor de o es null. - - es menor o igual que cero. - - - Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. - Tamaño mínimo de búfer. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - - - Devuelve la secuencia subyacente. - Secuencia subyacente. - 2 - - - Obtiene la codificación de caracteres que actualmente utiliza este objeto . - Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . - 2 - - - Borra el búfer interno. - 2 - - - Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene un valor que indica si la actual posición está al final de la secuencia. - Es true si la actual posición está al final de la secuencia; en caso contrario, es false. - Se ha eliminado la secuencia subyacente. - 1 - - - Objeto en torno a una secuencia vacía. - 1 - - - Devuelve el siguiente carácter disponible pero no lo consume. - Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. - El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. - Se produce un error de E/S. - 1 - - - Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. - Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Índice de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - La longitud del búfer menos es menor que . - El valor de es null. - - o es negativo. - Se produce un error de E/S, como el cierre de la secuencia. - 1 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - - o es negativo. - El se cierra. - Error de E/S. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. - El número de caracteres en la siguiente línea es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la secuencia. - Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. - El número de caracteres es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. - 1 - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - No se puede escribir en . - - is null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - - o es null. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . - Es true para que vacíe su búfer; en caso contrario, es false. - 1 - - - Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. - Secuencia en la que escribe este StreamWriter. - 2 - - - Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. - truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - - - Obtiene el donde se escribe el resultado. - - especificado en el constructor para la instancia actual o si no se ha especificado una codificación. - 2 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. - El sistema de escritura actual está cerrado. - Se produjo un error de E/S. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - 1 - - - Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe un carácter en la secuencia. - Carácter que se va a escribir en la secuencia. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una matriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una submatriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una cadena en la secuencia. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comienza la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Implementa que lee en una cadena. - 2 - - - Inicializa una nueva instancia de la clase que lee en la cadena especificada. - Cadena en la que debe inicializarse. - El parámetro es null. - - - Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Devuelve el siguiente carácter disponible pero no lo consume. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - El sistema de lectura actual está cerrado. - 2 - - - Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. - Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. - El sistema de lectura actual está cerrado. - 2 - - - Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . - Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Índice inicial del búfer. - Número de caracteres que se va a leer. - - es null. - La longitud del búfer menos es menor que . - - o son negativos. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. - El sistema de lectura actual está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - 2 - - - Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Contenido desde la posición actual hasta el final de la cadena subyacente. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. - El número de caracteres es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir información en una cadena.La información se almacena en el subyacente. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Inicializa una nueva instancia de la clase que escribe en el especificado. - Objeto StringBuilder en el que se va a escribir. - - es null. - - - Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. - Objeto StringBuilder en el que se va a escribir. - Objeto que controla las operaciones de formato. - - es null. - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene el donde se escribe el resultado. - Encoding donde se escribe el resultado. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - - - Devuelve el subyacente. - Objeto StringBuilder subyacente. - 2 - - - Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. - Cadena que contiene los caracteres escritos en el StringWriter actual. - 2 - - - Escribe un carácter en la cadena. - Carácter que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe una submatriz de caracteres en la cadena. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - - o son negativos. - ( + ) > .Length. - El sistema de escritura está cerrado. - 2 - - - Escribe una cadena en la cadena actual. - Cadena que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe un carácter en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena actual de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Representa un lector que puede leer una serie secuencial de caracteres. - 2 - - - Inicializa una nueva instancia de la clase . - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. - - - Proporciona un TextReader sin datos del que leer. - 1 - - - Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. - Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. - Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 2 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. - Línea siguiente del lector o null si se han leído todos los caracteres. - Se produce un error de E/S. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El objeto está cerrado. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. - Se produce un error de E/S. - El objeto está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. - El número de caracteres es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Almacena los caracteres de nueva línea usados para el TextWriter. - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. - Codificación de caracteres donde se escriben los resultados. - 1 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se desecha el sistema de escritura de texto. - El sistema de escritura está actualmente en uso por una operación de escritura anterior. - - - Obtiene un objeto que controla las operaciones de formato. - Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. - 2 - - - Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. - Cadena de terminador de línea para el TextWriter actual. - 2 - - - Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. - Objeto que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena en la cadena o secuencia de texto. - Cadena que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - El valor de o es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea en la cadena o secuencia. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - Posición del carácter en donde comenzar a leer datos. - Número máximo de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. - Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. - Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - Una cadena u objeto se pasa como null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml deleted file mode 100644 index 30dc29ab..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/fr/System.IO.xml +++ /dev/null @@ -1,2201 +0,0 @@ - - - - System.IO - - - - Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux d'entrée. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - - Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. - Flux d'entrée. - Encodage des caractères à utiliser. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux d'entrée. - Encodage des caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - ou a la valeur null. - - - Expose l'accès au flux sous-jacent de l'élément . - Flux sous-jacent associé à l'élément BinaryReader. - 2 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. - Nombre d'octets à lire. - La fin du flux est atteinte avant que n'ait pu être lu. - Une erreur d'E/S se produit. - - demandé est plus grand que la taille de la mémoire tampon interne. - - - Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. - Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. - 2 - - - Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. - Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre d'octets à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. - Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier 32 bits au format compressé. - Entier 32 bits au format compressé. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Le flux est endommagé. - - - Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. - true si l'octet est différent de zéro ; sinon, false. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. - Octet suivant lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. - Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. - Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Une erreur d'E/S se produit. - Le flux est fermé. - - est négatif. - 2 - - - Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. - Caractère lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Un caractère de substitution a été lu. - 2 - - - Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. - Nombre de caractères à lire. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Le flux est fermé. - Une erreur d'E/S se produit. - - est négatif. - 2 - - - Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. - Valeur décimale lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Valeur à virgule flottante de 8 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. - Entier signé de 2 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Entier signé de 4 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Entier signé de 8 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. - Octet signé lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Valeur à virgule flottante de 4 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. - Chaîne en cours de lecture. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. - Entier non signé de 2 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. - Entier non signé de 4 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. - Entier non signé de 8 octets lu dans ce flux. - La fin du flux est atteinte. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe qui écrit dans un flux. - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux de sortie. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. - Flux de sortie. - Encodage de caractères à utiliser. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux de sortie. - Encodage de caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Obtient le flux sous-jacent de . - Flux sous-jacent associé à BinaryWriter. - 1 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - 1 - - - Spécifie sans magasin de sauvegarde. - 1 - - - Contient le flux sous-jacent. - - - Définit la position dans le flux actuel. - Position dans le flux actuel. - Offset d'octet par rapport à . - Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. - Le pointeur de fichier a été déplacé vers un emplacement non valide. - La valeur n'est pas valide. - 1 - - - Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. - Valeur Boolean à écrire (0 ou 1). - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. - Octet non signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un tableau d'octets dans le flux sous-jacent. - Tableau d'octets contenant les données à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - a la valeur null. - 1 - - - Écrit une zone d'un tableau d'octets dans le flux actuel. - Tableau d'octets contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre d'octets à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Caractère Unicode de non-substitution à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - est un caractère de substitution unique. - 1 - - - Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Tableau de caractères contenant les données à écrire. - - a la valeur null. - Le flux est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. - Tableau de caractères contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. - Valeur décimale à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Valeur à virgule flottante de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. - Octet signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Valeur à virgule flottante de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. - Valeur à écrire. - Une erreur d'E/S se produit. - - a la valeur null. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier non signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier non signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier non signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un nombre entier 32 bits dans un format compressé. - Entier 32 bits à écrire. - La fin du flux est atteinte. - Le flux est fermé. - Le flux est fermé. - - - Exception levée en cas de tentative de lecture au-delà de la fin du flux. - 2 - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Exception qui est levée lorsque le format d'un flux de données n'est pas valide. - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. - Message d'erreur indiquant la raison de l'exception. - - - Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. - Message d'erreur indiquant la raison de l'exception. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. - Tableau d'octets non signés à partir duquel créer le flux actuel. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - - a la valeur null. - - ou est inférieur à zéro. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. - Taille initiale du tableau interne, en octets. - - est négatif. - - - Obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 2 - - - Obtient ou définit le nombre d'octets alloués pour ce flux. - Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. - La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. - Le flux actuel est fermé. - set est appelé sur un flux dont la capacité ne peut pas être modifiée. - 2 - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. - Jeton pour surveiller les demandes d'annulation. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplace la méthode afin qu'aucune action ne soit effectuée. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation. - Le flux a été supprimé. - - - Obtient la longueur du flux en octets. - Longueur du flux en octets. - Le flux est fermé. - 2 - - - Obtient ou définit la position actuelle dans le flux. - Position actuelle dans le flux. - La position correspond à une valeur négative ou à une valeur supérieure à . - Le flux est fermé. - 2 - - - Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. - Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. - Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - - soustrait à la longueur de la mémoire tampon est inférieur à . - L'instance du flux actuel est fermée. - 2 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet dans le flux actuel. - Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. - L'instance du flux actuel est fermée. - 2 - - - Définit la position dans le flux actuel à la valeur spécifiée. - Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. - Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. - Valeur de type , qui sert de point de référence à la recherche. - Tentative de recherche avant le début du flux. - - est supérieur à . - Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. - L'instance du flux actuel est fermée. - 2 - - - Définit la longueur du flux actuel à la valeur spécifiée. - Valeur à laquelle définir la longueur. - Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. - - est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. - 2 - - - Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . - Nouveau tableau d'octets. - 2 - - - Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. - true si la conversion a réussi ; sinon, false. - Segment de tableau d'octets à partir duquel ce flux a été créé. - - - Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre maximal d'octets à écrire. - - a la valeur null. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. - - soustrait à la longueur de la mémoire tampon est inférieur à . - - ou est négatif. - Une erreur d'E/S se produit. - L'instance du flux actuel est fermée. - 2 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux actuel. - Octet à écrire. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. - Le flux actuel est fermé. - 2 - - - Écrit le contenu complet de ce flux de mémoire dans un autre flux. - Flux dans lequel écrire ce flux de mémoire. - - a la valeur null. - Le flux en cours ou le flux cible est fermé. - 2 - - - Spécifie la position au sein d'un flux à utiliser pour la recherche. - 2 - - - Spécifie le début d'un flux. - - - Spécifie la position actuelle au sein d'un flux. - - - Spécifie la fin d'un flux. - - - Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe . - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux prend en charge la lecture ; sinon, false. - 1 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux prend en charge la recherche ; sinon, false. - 1 - - - Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - 2 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 1 - - - Lit les octets du flux actuel et les écrit dans un autre flux. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Flux vers lequel le contenu du flux actuel sera copié. - Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. - Une erreur d'E/S se produit. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - Le flux a été supprimé. - - - En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. - Valeur de type long représentant la longueur du flux en octets. - Une classe dérivée de Stream ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Élément Stream sans magasin de stockage. - 1 - - - En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. - Position actuelle dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. - Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. - Nombre maximal d'octets à lire dans le flux actuel. - La somme de et de est supérieure à la longueur de la mémoire tampon. - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. - Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. - Nouvelle position dans le flux actuel. - Offset d'octet par rapport au paramètre . - Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. - Longueur souhaitée du flux actuel en octets. - Une erreur d'E/S se produit. - Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. - Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre d'octets à écrire dans le flux actuel. - La somme des  et  est supérieure à la longueur du tampon. - - est null. - - ou  est un nombre négatif. - Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. - Le flux ne prend pas en charge l'écriture. - - a été appelée une fois que le flux a été fermé. - 1 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. - Octet à écrire dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié. - Flux à lire. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. - Flux à lire. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. - Flux à lire. - Encodage des caractères à utiliser. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - Taille minimale de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - - ou a la valeur null. - - est inférieur ou égal à zéro. - - - Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux à lire. - Encodage des caractères à utiliser. - true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. - Taille minimale de la mémoire tampon. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - - Retourne le flux sous-jacent. - Flux sous-jacent. - 2 - - - Obtient l'encodage de caractères actuel utilisé par l'objet actuel. - Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . - 2 - - - Efface la mémoire tampon interne. - 2 - - - Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. - true si la position actuelle dans le flux est à la fin du flux ; sinon, false. - Le flux sous-jacent a été supprimé. - 1 - - - Objet autour d'un flux vide. - 1 - - - Retourne le caractère disponible suivant, mais ne le consomme pas. - Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. - Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. - Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Index de auquel commencer l'écriture. - Nombre maximal de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S, telle que la fermeture du flux, se produit. - 1 - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S s'est produite. - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. - Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du flux. - Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. - Le nombre de caractères est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. - Le flux dans lequel écrire. - - n'est pas accessible en écriture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - - ou est null. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . - true pour forcer à vider sa mémoire tampon ; sinon, false. - 1 - - - Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. - Flux dans lequel ce StreamWriter écrit. - 2 - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - - - Obtient le dans lequel la sortie est écrite. - - spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. - 2 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. - Le writer actuel est fermé. - Une erreur d'E/S s'est produite. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - 1 - - - Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. - 1 - - - Écrit un caractère dans le flux. - Caractère à écrire dans le flux. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un sous-tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit une chaîne dans le flux. - Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire où commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire dans le flux.Si est null, rien n'est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un terminateur de ligne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Implémente qui lit une chaîne. - 2 - - - Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. - Chaîne à laquelle doit être initialisé. - Le paramètre est null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Retourne le prochain caractère disponible, mais ne le consomme pas. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Le lecteur actuel est fermé. - 2 - - - Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. - Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. - Le lecteur actuel est fermé. - 2 - - - Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . - Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Index de début dans la mémoire tampon. - Nombre de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Le lecteur actuel est fermé. - 2 - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. - Le lecteur actuel est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - 2 - - - Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. - Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le lecteur actuel est fermé. - 2 - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. - Le nombre de caractères est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. - Objet qui contrôle la mise en forme. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié. - StringBuilder dans lequel écrire. - - a la valeur null. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. - StringBuilder dans lequel écrire. - Objet qui contrôle la mise en forme. - - a la valeur null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Obtient le dans lequel la sortie est écrite. - Encoding dans lequel la sortie est écrite. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - - - Retourne le sous-jacent. - StringBuilder sous-jacent. - 2 - - - Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. - Chaîne contenant les caractères écrits dans le StringWriter en cours. - 2 - - - Écrit un caractère dans la chaîne. - Caractère à écrire. - Le writer est fermé. - 2 - - - Écrit un sous-tableau de caractères dans la chaîne. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - ou est négatif. - ( + )> .Length. - Le writer est fermé. - 2 - - - Écrit une chaîne dans la chaîne actuelle. - Chaîne à écrire. - Le writer est fermé. - 2 - - - Écrit un caractère dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans la chaîne actuelle de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Représente un lecteur capable de lire une série séquentielle de caractères. - 2 - - - Initialise une nouvelle instance de la classe . - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Fournit un TextReader sans données à lire. - 1 - - - Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. - Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. - Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. - La ligne suivante du lecteur ou null si tous les caractères ont été lus. - Une erreur d'E/S se produit. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - - est fermé. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. - Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. - Une erreur d'E/S se produit. - - est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. - Le nombre de caractères est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. - Objet qui contrôle la mise en forme. - - - Stocke les caractères de saut de ligne utilisés pour ce TextWriter. - - - Libère toutes les ressources utilisées par l'objet . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. - Encodage de caractères dans lequel la sortie est écrite. - 1 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le writer de texte est supprimé. - Le writer est actuellement utilisé par une opération d'écriture précédente. - - - Obtient un objet qui contrôle la mise en forme. - Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. - 2 - - - Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. - Chaîne de marque de fin de ligne pour le TextWriter actuel. - 2 - - - Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. - Objet à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne dans la chaîne ou le flux de texte. - Chaîne à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - - ou a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - Dans , position de caractère à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - Une chaîne ou un objet est passé en tant que null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml deleted file mode 100644 index 46070bec..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/it/System.IO.xml +++ /dev/null @@ -1,2123 +0,0 @@ - - - - System.IO - - - - Legge i tipi di dati primitivi come valori binari in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. - Flusso di input. - Il flusso non supporta la lettura, è null o è già chiuso. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. - Flusso di input. - Codifica dei caratteri da usare. - Il flusso non supporta la lettura, è null o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. - Flusso di input. - Codifica dei caratteri da usare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la lettura, è null o è già chiuso. - - o è null. - - - Espone l'accesso al flusso sottostante dell'oggetto . - Flusso sottostante associato all'oggetto BinaryReader. - 2 - - - Rilascia tutte le risorse usate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Inserisce nel buffer interno il numero specificato di byte letti dal flusso. - Numero di byte da leggere. - È stata raggiunta la fine del flusso prima che fosse possibile leggere . - Si è verificato un errore di I/O. - I richiesti sono superiori alla dimensione del buffer interno. - - - Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. - Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. - 2 - - - Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. - Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. - Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di byte da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. - Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di caratteri da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero a 32 bit in formato compresso. - Intero a 32 bit in formato compresso. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - Flusso danneggiato. - - - Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - true se il byte è diverso da zero; in caso contrario, false. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - Byte successivo letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. - Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. - Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è negativo. - 2 - - - Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Carattere letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - È stato letto un carattere surrogato. - 2 - - - Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. - Numero di caratteri da leggere. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Il flusso è chiuso. - Si è verificato un errore di I/O. - - è negativo. - 2 - - - Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. - Valore decimale letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. - Valore a virgola mobile a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. - Intero con segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Intero con segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. - Intero con segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. - Byte con segno letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Valore a virgola mobile a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. - Stringa da leggere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. - Intero senza segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero senza segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero senza segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe che scrive in un flusso. - - - Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. - Flusso di output. - Il flusso non supporta la scrittura o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. - Flusso di output. - Codifica dei caratteri da utilizzare. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. - Flusso di output. - Codifica dei caratteri da utilizzare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Ottiene il flusso sottostante dell'oggetto . - Flusso sottostante associato a BinaryWriter. - 1 - - - Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Specifica un oggetto privo di archivio di backup. - 1 - - - Contiene il flusso principale. - - - Imposta la posizione all'interno del flusso corrente. - Posizione all'interno del flusso corrente. - Offset dei byte relativo a . - Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. - Il puntatore a file è stato spostato in un percorso non valido. - Il valore di non è valido. - 1 - - - Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. - Valore Boolean da scrivere (0 o 1). - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una matrice di byte nel flusso sottostante. - Matrice di caratteri che contiene i dati da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è null. - 1 - - - Scrive un'area di una matrice di byte nel flusso corrente. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale nel parametro da cui iniziare la scrittura. - Numero di byte da scrivere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Carattere Unicode non surrogato da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è un carattere surrogato singolo. - 1 - - - Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - - è null. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 1 - - - Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale in dal quale avviare la scrittura. - Numero di caratteri da inserire. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. - Valore decimale da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Valore a virgola mobile a otto byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Valore a virgola mobile a quattro byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. - Valore da scrivere. - Si è verificato un errore di I/O. - - è null. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Inserisce un valore intero a 32 bit in un formato compresso. - Intero da 32 bit da scrivere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Il flusso è chiuso. - - - Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. - 2 - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - - - Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Eccezione generata se un flusso di dati è in un formato non valido. - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con un messaggio di errore specificato. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - - - Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. - Matrice di byte senza segno da cui creare il flusso corrente. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - - è null. - - o è minore di zero. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - o è un valore negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. - - è null. - Il valore di o è negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. - Dimensione iniziale in byte della matrice interna. - - è negativo. - - - Ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 2 - - - Ottiene o imposta il numero di byte allocati per questo flusso. - Lunghezza della parte usabile del buffer per il flusso. - È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. - Il flusso corrente è chiuso. - set è stato richiamato su un flusso del quale non è possibile modificare la capacità. - 2 - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. - Token da monitorare per le richieste di annullamento. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. - 2 - - - Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento. - Il flusso è stato eliminato. - - - Ottiene la lunghezza in byte del flusso. - Lunghezza del flusso in byte. - Il flusso è chiuso. - 2 - - - Ottiene o imposta la posizione corrente all'interno del flusso. - Posizione corrente all'interno del flusso. - La posizione è impostata su un valore negativo o maggiore di . - Il flusso è chiuso. - 2 - - - Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. - Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. - Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. - Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - - sottratto alla lunghezza del buffer è minore di . - L'istanza del flusso corrente è chiusa. - 2 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso corrente. - Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la posizione all'interno del flusso corrente sul valore specificato. - Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. - Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. - Valore di tipo , che funge da punto di riferimento per la ricerca. - La ricerca viene tentata prima dell'inizio del flusso. - - è maggiore di . - Il valore di non è valido. -oppure- causato da un overflow aritmetico. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la lunghezza del flusso corrente sul valore specificato. - Valore su cui impostare la lunghezza. - Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. - - è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. - 2 - - - Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . - Nuova matrice di byte. - 2 - - - Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. - true se la conversione riesce; in caso contrario, false. - Segmento di matrice di byte da cui è stato creato questo flusso. - - - Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero massimo di byte da scrivere. - - è null. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. - - sottratto alla lunghezza del buffer è minore di . - - o è un valore negativo. - Si è verificato un errore di I/O. - L'istanza del flusso corrente è chiusa. - 2 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente all'interno del flusso corrente. - Byte da scrivere. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. - Il flusso corrente è chiuso. - 2 - - - Scrive l'intero contenuto del flusso di memoria in un altro flusso. - Flusso in cui scrivere il flusso di memoria. - - è null. - Il flusso corrente o di destinazione è chiuso. - 2 - - - Specifica la posizione in un flusso da utilizzare per le ricerche. - 2 - - - Specifica l'inizio di un flusso. - - - Specifica la posizione corrente all'interno di un flusso. - - - Specifica la fine di un flusso. - - - Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe . - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso supporta la lettura; in caso contrario, false. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso supporta la ricerca; in caso contrario, false. - 1 - - - Ottiene un valore che determina se il flusso corrente prevede il timeout. - Valore che determina se il flusso corrente prevede il timeout. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 1 - - - Legge i byte dal flusso corrente e li scrive in un altro flusso. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Si è verificato un errore di I/O. - 2 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - Il flusso è stato eliminato. - - - Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. - Valore long che rappresenta la lunghezza del flusso in byte. - Una classe derivata da Stream non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Oggetto Stream privo di archivio di backup. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. - Posizione corrente all'interno del flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. - Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. - Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. - Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. - Numero massimo di byte da leggere dal flusso corrente. - La somma di e è maggiore della lunghezza del buffer. - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. - Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. - Nuova posizione all'interno del flusso corrente. - Offset dei byte rispetto al parametro . - Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. - Lunghezza desiderata del flusso corrente in byte. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. - Matrice di byte.Questo metodo copia i byte da nel flusso corrente. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero di byte da scrivere nel flusso corrente. - La somma di  e  è maggiore della lunghezza del buffer. - - è null. - - o  è negativo. - Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. - Il flusso non supporta la scrittura. - - è stato chiamato dopo la chiusura del flusso. - 1 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. - Byte da scrivere nel flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura o è già chiuso. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato. - Flusso da leggere. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. - Flusso da leggere. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. - Flusso da leggere. - Codifica dei caratteri da usare. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - Dimensione minima del buffer. - Il flusso non supporta la lettura. - - o è null. - - è minore o uguale a zero. - - - Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. - Flusso da leggere. - Codifica dei caratteri da usare. - true per cercare i byte order mark all'inizio del file; in caso contrario, false. - Dimensione minima del buffer. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - - Restituisce il flusso sottostante. - Flusso sottostante. - 2 - - - Ottiene la codifica caratteri corrente usata dall'oggetto corrente. - Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . - 2 - - - Cancella il buffer interno. - 2 - - - Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. - true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. - Il flusso sottostante è stato eliminato. - 1 - - - Oggetto che include un flusso vuoto. - 1 - - - Restituisce il carattere successivo disponibile senza usarlo. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. - Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Indice di da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O, come la chiusura del flusso. - 1 - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. - Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. - Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. - Il numero di caratteri è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. - Flusso in cui scrivere. - - non è modificabile. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - - o è null. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - - o è null. - - è negativo. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - o è null. - - è negativo. - - non è modificabile. - - - Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . - true per forzare lo scaricamento del buffer; in caso contrario, false. - 1 - - - Ottiene il flusso sottostante che si interfaccia con un archivio di backup. - Flusso in cui StreamWriter scrive. - 2 - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - - - Ottiene l'oggetto in cui viene scritto l'output. - Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. - 2 - - - Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. - Il writer corrente è chiuso. - Si è verificato un errore di I/O. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive un carattere nel flusso. - Carattere da scrivere nel flusso. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una matrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una sottomatrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una stringa nel flusso. - Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Implementa un oggetto che legge da una stringa. - 2 - - - Inizializza una nuova istanza della classe che legge dalla stringa specificata. - Stringa sulla quale inizializzare . - Il parametro è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Restituisce il carattere successivo disponibile senza utilizzarlo. - Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Il lettore corrente è chiuso. - 2 - - - Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. - Il lettore corrente è chiuso. - 2 - - - Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . - Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Indice iniziale nel buffer. - Numero di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. - Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. - Il lettore corrente è chiuso. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - 2 - - - Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Contenuto dalla posizione corrente alla fine della stringa sottostante. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. - Il numero di caratteri è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il controllo di formato specificato. - Oggetto che controlla la formattazione. - - - Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. - Oggetto StringBuilder in cui scrivere. - - è null. - - - Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. - Oggetto StringBuilder in cui scrivere. - Oggetto che controlla la formattazione. - - è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Recupera l'oggetto in cui viene scritto l'output. - Encoding in cui viene scritto l'output. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di svuotamento asincrona. - - - Restituisce l'oggetto sottostante. - StringBuilder sottostante. - 2 - - - Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. - Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. - 2 - - - Scrive un carattere nella stringa. - Carattere da inserire. - Il writer è chiuso. - 2 - - - Scrive una sottomatrice di caratteri nella stringa. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - Il valore di o è negativo. - ( + )> .Length. - Il writer è chiuso. - 2 - - - Scrive una stringa nella stringa corrente. - Stringa da scrivere. - Il writer è chiuso. - 2 - - - Scrive un carattere nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nella stringa corrente in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. - 2 - - - Inizializza una nuova istanza della classe . - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. - 1 - - - Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. - Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 2 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. - Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. - Si è verificato un errore di I/O. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - La classe è chiusa. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. - Si è verificato un errore di I/O. - La classe è chiusa. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. - Il numero di caratteri è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il provider di formato specificato. - Oggetto che controlla la formattazione. - - - Archivia i caratteri di nuova riga usati per questo TextWriter. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. - Codifica caratteri in cui viene scritto l'output. - 1 - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il writer di testo viene eliminato. - Il writer è attualmente utilizzato da un'operazione di scrittura precedente. - - - Ottiene un oggetto che controlla la formattazione. - Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. - 2 - - - Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. - Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. - 2 - - - Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nella stringa o flusso di testo. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri nella stringa o flusso di testo. - Matrice di caratteri da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. - Oggetto da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa nella stringa o nel flusso di testo. - Stringa da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - - o è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso o nella stringa di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - Posizione del carattere in dalla quale avviare la lettura dei dati. - Numero massimo di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - Viene passato un oggetto o una stringa come null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml deleted file mode 100644 index 4114d626..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/ja/System.IO.xml +++ /dev/null @@ -1,2264 +0,0 @@ - - - - System.IO - - - - プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 - 2 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - 使用する文字エンコーディング。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - は null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 入力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - または が null です。 - - - - の基になるストリームへのアクセスを公開します。 - BinaryReader に関連付けられた、基になるストリーム。 - 2 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 - 読み取るバイト数。 - - 分のバイトを読み取る前にストリームの末尾に到達しました。 - I/O エラーが発生しました。 - 要求された が、内部バッファー サイズより大きくなっています。 - - - 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 - 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 - 2 - - - 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 - - に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取るバイト数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 - バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取る文字の数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 32 ビット整数を圧縮形式で読み取ります。 - 圧縮形式の 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - ストリームが破損しています。 - - - 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った次のバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 - 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - が負の値です。 - 2 - - - 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 現在のストリームから読み取った文字。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - サロゲート文字が読み取られました。 - 2 - - - 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 - 読み取る文字の数。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - - が負の値です。 - 2 - - - 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 - 現在のストリームから読み取った 10 進数値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った符号付きバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 - 読み取った文字列。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号なし整数。 - ストリームの末尾に到達しました。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 - 2 - - - ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - は null なので、 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - 使用する文字エンコーディング。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 出力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - - の基になるストリームを取得します。 - BinaryWriter に関連付けられた、基になるストリーム。 - 1 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - バッキング ストアを持たない を指定します。 - 1 - - - 基になるストリームを保持します。 - - - 現在のストリーム内の位置を設定します。 - 現在のストリームの位置。 - - からのバイト オフセット。 - 新しい位置を取得するための参照ポイントを示す フィールド。 - ファイル ポインターが無効な位置に移動しました。 - - 値が無効です。 - 1 - - - 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 - 書き込む Boolean 値 (0 または 1)。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号なしバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 基になるストリームにバイト配列を書き込みます。 - 書き込むデータが格納されているバイト配列。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は null なので、 - 1 - - - 現在のストリームにバイト配列の特定の領域を書き込みます。 - 書き込むデータが格納されているバイト配列。 - - 内の書き込み開始点。 - 書き込むバイト数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む非サロゲート Unicode 文字。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は、単一のサロゲート文字です。 - 1 - - - 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - は null なので、 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - 内の書き込み開始点。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 - 書き込む 10 進値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号付きバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む値。 - I/O エラーが発生しました。 - - は null なので、 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 32 ビット整数を圧縮形式で書き込みます。 - 書き込む 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - ストリームが閉じられました。 - - - ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 - 2 - - - メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 - - - メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - - - 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - データ ストリームが無効な形式である場合にスローされる例外。 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - - - この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 - - - 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - 現在のストリームを作成する符号なしバイトの配列。 - - は null です。 - - - - プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - - バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - - は null です。 - - または が 0 未満です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 - バイト単位の内部配列の初期サイズ。 - - が負の値です。 - - - 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 2 - - - ストリームに割り当てられたバイト数を取得または設定します。 - ストリームに対してバッファーが使用できる部分の長さ。 - 容量が負の値または現在のストリーム長より小さい値に設定されています。 - 現在のストリームが閉じています。 - 容量を変更できないストリームに対して set が呼び出されました。 - 2 - - - 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 - キャンセル要求を監視するためのトークン。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - アクションが実行されないように、 メソッドをオーバーライドします。 - 2 - - - このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。 - ストリームは破棄されています。 - - - バイト単位のストリーム長を取得します。 - バイト単位のストリーム長。 - ストリームが閉じられました。 - 2 - - - ストリームの現在位置を取得または設定します。 - ストリーム内の現在位置。 - 位置が負の値または より大きい値に設定されています。 - ストリームが閉じられました。 - 2 - - - 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 - バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 - このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 - 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームからバイトを読み取ります。 - - にキャストしたバイト。ストリームの末尾に達した場合は -1。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム内の位置を指定した値に設定します。 - 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 - ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 - シーク参照ポイントとして機能する 型の値。 - ストリームの先頭より前をシークしようとしました。 - - が より大きくなっています。 - 無効な があります。または によって算術オーバーフローが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム長を指定した値に設定します。 - 長さを設定する値。 - 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 - - が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 - 2 - - - - プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 - 新しいバイト配列。 - 2 - - - このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 - 変換が成功した場合は true。それ以外の場合は false。 - このストリームの作成元のバイト配列セグメント。 - - - バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 - データの書き込み元となるバッファー。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリーム内の現在位置に 1 バイトを書き込みます。 - 書き込むバイト。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 - 現在のストリームが閉じています。 - 2 - - - メモリ ストリームの内容全体を別のストリームに書き込みます。 - このメモリ ストリームが書き込まれるストリーム。 - - は null です。 - 現在のストリームまたは対象のストリームは閉じています。 - 2 - - - シークに使用するストリームの場所を指定します。 - 2 - - - ストリームの先頭を指定します。 - - - ストリーム内の現在位置を指定します。 - - - ストリームの末尾を指定します。 - - - バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 - ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 - ストリームがシークをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 - 現在のストリームがタイムアウトできるかどうかを決定する値。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - によって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - I/O エラーが発生しました。 - 2 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。既定値は です。 - ストリームは破棄されています。 - - - 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 - ストリーム長 (バイト単位) を表す long 値。 - Stream から派生したクラスがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - バッキング ストアを持たない Stream。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 - ストリーム内の現在位置。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 - バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 - バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 - 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームから読み取る最大バイト数。 - - と の合計値が、バッファー長より大きい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 - Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 - 現在のストリーム内の新しい位置。 - - パラメーターからの相対バイト オフセット。 - 新しい位置を取得するために使用する参照ポイントを示す 型の値。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 - 現在のストリームの希望の長さ (バイト数)。 - I/O エラーが発生しました。 - ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 - バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームに書き込むバイト数。 - 合計  と  がバッファーの長さより大きい。 - - nullです。 - - または  が負の値です。 - 指定したファイルが見つからないなど、I/O エラーが発生しました。 - ストリームは書き込みをサポートしません。 - - ストリームが閉じられた後が呼び出されました。 - 1 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - ストリームに書き込むバイト。 - I/O エラーが発生しました。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 1 - - - 指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - - が読み取りをサポートしていません。 - - は null です。 - - - バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - は null です。 - - - 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - 最小バッファー サイズ。 - ストリームは読み取りをサポートしません。 - - または が null です。 - - が 0 以下です。 - - - 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 読み取るストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 - 最小バッファー サイズ。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - - - 基になるストリームを返します。 - 基になるストリーム。 - 2 - - - 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 - 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 - 2 - - - 内部バッファーをクリアします。 - 2 - - - 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 - 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 - 基になるストリームは破棄されています。 - 1 - - - 空のストリームの オブジェクト。 - 1 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 - 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 - 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みの開始位置を示す のインデックス。 - 読み取り対象の最大文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。たとえば、ストリームがクローズされています。 - 1 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 - 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - すべての文字の現在位置から末尾までを読み込みます。 - ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 - 1 - - - UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - - が書き込み可能ではありません。 - - は null です。 - - - 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - - または が null です。 - - が書き込み可能ではありません。 - - - 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - true to leave the stream open after the object is disposed; otherwise, false. - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - - が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 - - に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 - 1 - - - バッキング ストアと連結する、基になるストリームを取得します。 - この StreamWriter が書き込むストリーム。 - 2 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - - - 出力の書き込みに使用する を取得します。 - 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 - 2 - - - 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 - 現在のライターがクローズされています。 - I/O エラーが発生しました。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - 1 - - - このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 - 1 - - - ストリームに文字を書き込みます。 - ストリームに書き込む文字。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列を書き込みます。 - 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列の一部を書き込みます。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字列を書き込みます。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - I/O エラーが発生しました。 - 1 - - - 文字を非同期でストリームに書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列から読み取る を実装します。 - 2 - - - 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 - - を初期化する目的の文字列。 - - パラメーターが null です。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 - 基になる文字列の次の文字。または使用できる文字がない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 - バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - バッファー内の開始インデックス。 - 読み取る文字の数。 - - は null なので、 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - 現在のリーダーが閉じています。 - 2 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 - 現在の文字列の次の行。文字列の末尾に到達した場合は null。 - 現在のリーダーが閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 2 - - - 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 - 基になる文字列の現在位置から末尾までの内容。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 現在のリーダーが閉じています。 - 2 - - - 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - - は null なので、 - - - 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - 書式を制御する オブジェクト。 - - は null なので、 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 出力の書き込みに使用する を取得します。 - 出力の書き込み時に適用する Encoding。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - - - 基になる を返します。 - 基になる StringBuilder。 - 2 - - - 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 - 現在の StringWriter に書き込まれた文字を格納している文字列。 - 2 - - - 文字列に文字を書き込みます。 - 書き込む文字。 - ライターが閉じられました。 - 2 - - - 文字配列の一部を文字列に書き込みます。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - または が負の値です。 - ( + )> 。Length. - ライターが閉じられました。 - 2 - - - 現在の文字列に文字列を書き込みます。 - 書き込む文字列。 - ライターが閉じられました。 - 2 - - - 文字列に文字を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に文字列を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 一連の文字を読み取ることができるリーダーを表します。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り対象のデータを TextReader に提供しません。 - 1 - - - リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 - テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 2 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 - リーダーの次の行。またはすべての文字が読み取られた場合は null。 - I/O エラーが発生しました。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - - が閉じています。 - 次の行の文字数が、 を超えています。 - 1 - - - 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 - テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 - I/O エラーが発生しました。 - - が閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 次の行の文字数が、 を超えています。 - 1 - - - テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - この TextWriter で使用する改行文字を格納します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 - 出力の書き込み時に適用する文字エンコーディング。 - 1 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - テキスト ライターは破棄されます。 - ライターは現在、前の書き込み操作で使用中です。 - - - 書式を制御するオブジェクトを取得します。 - 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 - 2 - - - 現在の TextWriter で使用される行終端文字列を取得または設定します。 - 現在の TextWriter で使用する行終端文字列。 - 2 - - - バッキング ストアを持たない書き込み専用の TextWriter を提供します。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字配列をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込みます。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込むオブジェクト。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込みます。 - 書き込む文字列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - - または が null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をテキスト文字列またはストリームに書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - データの読み込みを開始する、 内の文字の位置。 - 書き込む文字の最大数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - 文字列またはオブジェクトが null として渡されました。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml deleted file mode 100644 index 145ab498..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/ko/System.IO.xml +++ /dev/null @@ -1,2262 +0,0 @@ - - - - System.IO - - - - 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. - 2 - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 가 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 또는 가 null인 경우 - - - - 의 내부 스트림에 대한 액세스를 노출합니다. - BinaryReader와 관련된 내부 스트림입니다. - 2 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. - 읽을 바이트 수입니다. - - 를 읽기 전에 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 요청된 가 내부 버퍼 크기보다 큰 경우 - - - 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. - 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. - 2 - - - 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. - - 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 압축 형식의 32비트 정수를 읽습니다. - 압축 형식의 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 스트림이 손상되었습니다. - - - 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 바이트가 0이 아니면 true이고 0이면 false입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 다음 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. - 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 현재 스트림에서 읽은 문자입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 서로게이트 문자를 읽은 경우 - 2 - - - 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. - 읽을 문자 수입니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 10진 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. - 읽어 오는 문자열입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. - 2 - - - 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 가 null입니다. - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - - 의 내부 스트림을 가져옵니다. - BinaryWriter와 관련된 내부 스트림입니다. - 1 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 1 - - - 백업 저장소가 없는 를 지정합니다. - 1 - - - 내부 스트림을 보유합니다. - - - 현재 스트림 내에서 위치를 설정합니다. - 현재 스트림에서의 위치입니다. - - 에 상대적인 바이트 오프셋입니다. - 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. - 파일 포인터가 잘못된 위치로 이동한 경우 - - 값이 잘못된 경우 - 1 - - - false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. - 쓸 Boolean 값(0 또는 1)입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 없는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 내부 스트림에 바이트 배열을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 null입니다. - 1 - - - 현재 스트림에 바이트 배열 영역을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 단일 서로게이트 문자인 경우 - 1 - - - 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - - 가 null입니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. - 출력할 10진수 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 있는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - - 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 값입니다. - I/O 오류가 발생하는 경우 - - 가 null입니다. - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 압축 형식의 32비트 정수를 씁니다. - 쓸 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - 스트림이 닫혀 있는 경우 - - - 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. - 2 - - - 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - - 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - - - 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - - - 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 현재 스트림을 만들 부호 없는 바이트의 배열입니다. - - 가 null인 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - - 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - - 가 null인 경우 - - 또는 가 0보다 작은 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 내부 배열의 초기 크기(바이트)입니다. - - 가 음수인 경우 - - - 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 2 - - - 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. - 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. - 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 - 현재 스트림이 닫혀 있는 경우 - 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 - 2 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. - 취소 요청을 모니터링할 토큰입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - - 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다. - 스트림이 삭제된 경우 - - - 스트림의 길이(바이트)를 가져옵니다. - 스트림의 길이(바이트)입니다. - 스트림이 닫혀 있는 경우 - 2 - - - 스트림 내의 현재 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - 위치가 음수 값이나 보다 큰 값으로 설정된 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. - 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. - 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트를 읽습니다. - - 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림 내의 위치를 지정된 값으로 설정합니다. - 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. - 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. - 검색 참조 지점 역할을 하는 형식의 값입니다. - 스트림의 시작 전에 검색하려고 한 경우 - - 가 보다 큰 경우 - 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림의 길이를 지정된 값으로 설정합니다. - 길이를 설정할 값입니다. - 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 - - 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. - 2 - - - - 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. - 새 바이트 배열입니다. - 2 - - - 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. - 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. - 이 스트림을 만든 바이트 배열 세그먼트입니다. - - - 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. - 데이터를 쓸 버퍼입니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 위치에서 현재 스트림에 바이트를 씁니다. - 쓸 바이트입니다. - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 - 현재 스트림이 닫혀 있는 경우 - 2 - - - 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. - 이 메모리 스트림을 쓸 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 닫혀 있는 경우 - 2 - - - 탐색에 사용할 스트림 내 위치를 지정합니다. - 2 - - - 스트림의 맨 앞을 지정합니다. - - - 스트림 내의 현재 위치를 지정합니다. - - - 스트림의 맨 끝을 지정합니다. - - - 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. - 2 - - - 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 에서 사용하는 모든 리소스를 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. - I/O 오류가 발생하는 경우 - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - 스트림이 삭제된 경우 - - - 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. - 스트림 길이(바이트)를 나타내는 long 값입니다. - Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 백업 저장소가 없는 Stream입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - I/O 오류가 발생하는 경우 - 스트림이 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. - 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. - 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에서 읽을 최대 바이트 수입니다. - - 와 의 합계가 버퍼 길이보다 큰 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. - Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. - 현재 스트림 내의 새 위치입니다. - - 매개 변수에 상대적인 바이트 오프셋입니다. - 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. - 원하는 현재 스트림의 길이(바이트)입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. - 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에 쓸 바이트 수입니다. - 총  및  버퍼 길이 보다 큽니다. - - null입니다. - - 또는  음수입니다. - 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. - 스트림이 쓰기를 지원하지 않습니다. - - 스트림이 닫힌 후 호출 되었습니다. - 1 - - - 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. - 스트림에 쓸 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 1 - - - 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - 최소 버퍼 크기입니다. - 스트림이 읽기를 지원하지 않습니다. - - 또는 가 null인 경우 - - 가 0보다 작거나 같은 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. - 최소 버퍼 크기입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - - - 내부 스트림을 반환합니다. - 내부 스트림입니다. - 2 - - - 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. - 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. - 2 - - - 내부 버퍼를 지웁니다. - 2 - - - 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. - 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. - 내부 스트림이 삭제된 경우 - 1 - - - 빈 스트림 주위의 개체입니다. - 1 - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - - 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. - 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 인덱스입니다. - 읽을 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫히는 등의 I/O 오류가 발생한 경우 - 1 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. - 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - - 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. - 1 - - - UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - - 에 쓸 수 없는 경우 - - 가 null인 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - - 또는 가 null인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - true to leave the stream open after the object is disposed; otherwise, false. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - - 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. - - 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. - 1 - - - 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. - 이 StreamWriter가 쓰고 있는 스트림입니다. - 2 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - - - 출력이 쓰여질 을 가져옵니다. - 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. - 2 - - - 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. - 현재 writer가 닫힌 경우 - I/O 오류가 발생한 경우 - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - 1 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. - 1 - - - 스트림에 문자를 씁니다. - 스트림에 쓸 문자입니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자의 하위 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자열을 씁니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작할 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 줄 종결자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열에서 읽어오는 를 구현합니다. - 2 - - - 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. - - 가 초기화되어야 하는 문자열입니다. - - 매개 변수가 null인 경우 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 버퍼의 시작 인덱스입니다. - 읽을 문자 수입니다. - - 가 null입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. - 현재 판독기가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 2 - - - 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. - 내부 문자열의 현재 위치에서 끝까지의 내용입니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 형식 지정을 제어하는 개체입니다. - - - 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - - 가 null입니다. - - - 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - 형식 지정을 제어하는 개체입니다. - - 가 null입니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 출력이 쓰여질 을 가져옵니다. - 출력이 쓰여질 Encoding입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 비동기 플러시 작업을 나타내는 작업입니다. - - - 내부 를 반환합니다. - 내부 StringBuilder입니다. - 2 - - - 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. - 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. - 2 - - - 문자를 문자열에 씁니다. - 쓸 문자입니다. - 작성기가 닫힌 경우 - 2 - - - 문자의 하위 배열을 문자열에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 또는 가 음수인 경우 - ( + )> 인 경우Length. - 작성기가 닫힌 경우 - 2 - - - 문자를 현재 문자열에 씁니다. - 쓸 문자열입니다. - 작성기가 닫힌 경우 - 2 - - - 문자를 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자를 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - TextReader에 읽을 데이터를 제공하지 않습니다. - 1 - - - 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. - I/O 오류가 발생하는 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - - 가 닫힌 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. - I/O 오류가 발생하는 경우 - - 가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 서식 지정을 제어하는 개체입니다. - - - 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. - 출력을 쓰는 문자 인코딩입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. - - - 서식 지정을 제어하는 개체를 가져옵니다. - 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. - 2 - - - 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. - 현재 TextWriter의 줄 종결자 문자열입니다. - 2 - - - 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. - 1 - - - Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - - 또는 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - 데이터 읽기를 시작하는 의 문자 위치입니다. - 쓸 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - 문자열이나 개체가 null로 전달되는 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml deleted file mode 100644 index d9ad6103..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/ru/System.IO.xml +++ /dev/null @@ -1,2023 +0,0 @@ - - - - System.IO - - - - Считывает примитивные типы данных как двоичные значения в заданной кодировке. - 2 - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Входной поток. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. - Входной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Входной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Параметр или имеет значение null. - - - Предоставляет доступ к базовому потоку объекта . - Базовый поток, связанный с объектом BinaryReader. - 2 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. - Количество байтов, чтение которых необходимо выполнить. - Конец потока достигнут раньше, чем было выполнено чтение байтов. - Ошибка ввода-вывода. - Запрошенное значение превышает размер внутреннего буфера. - - - Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. - Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. - Ошибка ввода-вывода. - Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. - 2 - - - Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. - Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Количество байтов, чтение которых необходимо выполнить. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. - Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Число символов для чтения. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число в сжатом формате. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Поток поврежден. - - - Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. - Значение true, если байт не равен нулю; в противном случае — значение false. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. - Следующий байт, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. - Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. - Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Ошибка ввода-вывода. - Поток закрыт. - Значение отрицательно. - 2 - - - Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Символ, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Выполнено чтение символа-заместителя. - 2 - - - Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. - Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. - Количество символов, которое необходимо считать. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Поток закрыт. - Ошибка ввода-вывода. - Значение отрицательно. - 2 - - - Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. - Десятичное значение, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Число с плавающей запятой длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Целое число со знаком длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. - Байт со знаком, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Число с плавающей запятой длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. - Считываемая строка. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число без знака длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число без знака длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. - Целое число без знака длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. - 2 - - - Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Выходной поток. - Поток не поддерживает запись или был закрыт до начала операции. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. - Выходной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Выходной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Получает базовый поток . - Базовый поток, связанный с объектом BinaryWriter. - 1 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Задает без резервного хранилища. - 1 - - - Содержит базовый поток. - - - Задает позицию в текущем потоке. - Позиция в текущем потоке. - Смещение в байтах относительно . - Поле указывает точку отсчета, относительно которой указывается новая позиция. - Указатель позиции в файле перемещен в недопустимую позицию. - Значение является недопустимым. - 1 - - - Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. - Записываемое в поток значение типа Boolean (0 или 1). - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. - Записываемый в поток байт без знака. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись массива байтов в базовый поток. - Массив байтов, содержащий записываемые в поток данные. - Ошибка ввода-вывода. - Поток закрыт. - Параметр имеет значение null. - 1 - - - Выполняет запись части массива байтов в текущий поток. - Массив байтов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество записываемых байтов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. - Незаменяющий символ Юникода, который необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - - представляет собой единичный символ-заместитель. - 1 - - - Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. - Массив символов, содержащий записываемые в поток данные. - Параметр имеет значение null. - Поток закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. - Массив символов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. - Десятичное значение, которое необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число со знаком размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число со знаком размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число со знаком размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. - Байт со знаком, который необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. - Записываемое значение. - Ошибка ввода-вывода. - Параметр имеет значение null. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число без знака размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число без знака размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число без знака размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число, которое необходимо записать. - Достигнут конец потока. - Поток закрыт. - Поток закрыт. - - - Исключение, которое создается при попытке выполнить чтение за пределами потока. - 2 - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - - - Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Исключение возникает, когда поток данных имеет недопустимый формат. - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным сообщением об ошибке. - Сообщение об ошибке с объяснением причин исключения. - - - Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. - Сообщение об ошибке с объяснением причин исключения. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. - Массив байтов без знака, из которого создается текущий поток. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Свойство имеет значение null. - Значение параметра или меньше нуля. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - Параметр или имеет отрицательное значение. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. - Исходный размер внутреннего массива в байтах. - Значение отрицательно. - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 2 - - - Возвращает или задает число байтов, выделенных для этого потока. - Длина применимой к использованию части буфера для потока. - Заданная емкость отрицательная или меньше текущей длины потока. - Текущий поток закрыт. - set вызывается для потока, емкость которого нельзя изменить. - 2 - - - Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля. - Токен для отслеживания запросов отмены. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Переопределяет метод так, что никакие действия не выполняются. - 2 - - - Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены. - Поток был ликвидирован. - - - Возвращает длину потока в байтах. - Длина потока в байтах. - Поток закрыт. - 2 - - - Возвращает или задает текущее положение в потоке. - Текущее положение в потоке. - В качестве положения задано отрицательное значение или значение, большее . - Поток закрыт. - 2 - - - Считывает блок байтов из текущего потока и записывает данные в буфер. - Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. - При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом меньше, чем . - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из текущего потока. - Байт приводится к типу или -1, если достигнут конец потока. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для положения в текущем потоке. - Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. - Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. - Значение типа , которое действует как точка ссылки поиска. - Попытка поиска выполняется до начала потока. - Значение больше значения . - - недопустим. -или-Значение вызвало арифметическое переполнение. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для длины текущего потока. - Значение задаваемой длины. - Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. - Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. - 2 - - - Записывает содержимое потока в массив байтов независимо от свойства . - Новый массив байтов. - 2 - - - Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. - Значение true, если преобразование прошло успешно; в противном случае — значение false. - Сегмент массива байтов, из которого был создан данный поток. - - - Записывает в текущий поток блок байтов, используя данные, считанные из буфера. - Буфер, из которого записываются данные. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. - Длина буфера за вычетом меньше, чем . - Параметр или имеет отрицательное значение. - Ошибка ввода-вывода. - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение текущего потока. - Записываемый байт. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. - Текущий поток закрыт. - 2 - - - Записывает все содержимое данного потока памяти в другой поток. - Поток, в который требуется осуществить запись данного потока памяти. - Свойство имеет значение null. - Текущий или конечный поток закрыт. - 2 - - - Задает позицию в потоке, используемую для поиска. - 2 - - - Задает начало потока. - - - Задает текущее положение в потоке. - - - Задает конец потока. - - - Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса . - - - При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. - Значение true, если поток поддерживает чтение; в противном случае — значение false. - 1 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. - Значение true, если поток поддерживает поиск; в противном случае — значение false. - 1 - - - Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. - Значение, которое показывает, может ли для данного потока истечь время ожидания. - 2 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 1 - - - Считывает байты из текущего потока и записывает их в другой поток. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Поток, в который будет скопировано содержимое текущего потока. - Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает все ресурсы, занятые модулем . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. - Ошибка ввода-вывода. - 2 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Поток был ликвидирован. - - - При переопределении в производном классе получает длину потока в байтах. - Длинное значение, представляющее длину потока в байтах. - Класс, созданный на основе класса Stream, не поддерживает возможность поиска. - Методы были вызваны после закрытия потока. - 1 - - - Объект Stream без резервного хранилища. - 1 - - - При переопределении в производном классе получает или задает позицию в текущем потоке. - Текущее положение в потоке. - Ошибка ввода-вывода. - Этот поток не поддерживает поиск. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. - Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. - Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. - Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. - Максимальное количество байтов, которое должно быть считано из текущего потока. - Сумма значений параметров и больше длины буфера. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 1 - - - Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. - Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - При переопределении в производном классе задает позицию в текущем потоке. - Новая позиция в текущем потоке. - Смещение в байтах относительно параметра . - Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. - Ошибка ввода-вывода. - Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе задает длину текущего потока. - Нужная длина текущего потока в байтах. - Ошибка ввода-вывода. - Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 2 - - - При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. - Массив байтов.Этот метод копирует байты из в текущий поток. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Количество байтов, которое необходимо записать в текущий поток. - Сумма  и  больше, чем длина буфера. - - — null. - - или  является отрицательным. - Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. - Поток не поддерживает запись. - - был вызван после закрытия потока. - 1 - - - Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. - Байт, записываемый в поток. - Ошибка ввода-вывода. - Поток не поддерживает запись или был закрыт до начала операции. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 1 - - - Инициализирует новый экземпляр класса для заданного потока. - Поток, который нужно считать. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. - Поток, который нужно считать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - Минимальный размер буфера. - Поток не поддерживает чтение. - Параметр или имеет значение null. - Значение параметра меньше или равно нулю. - - - Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. - Считываемый поток. - Кодировка символов, которую нужно использовать. - Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. - Минимальный размер буфера. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - - - Возвращает основной поток. - Основной поток. - 2 - - - Возвращает текущую кодировку символов, используемую текущим объектом . - Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. - 2 - - - Очищает внутренний буфер. - 2 - - - Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. - Значение true, если текущее положение находится в конце потока; в противном случае — значение false. - Основной поток удален. - 1 - - - Объект для пустого потока. - 1 - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. - Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. - Ошибка ввода-вывода. - 1 - - - Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. - Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Индекс , с которого требуется начать запись. - Максимальное число считываемых символов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Возникает ошибка ввода-вывода, например закрывается поток. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Произошла ошибка ввода-вывода. - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Следующая строка из входного потока или значение null, если достигнут конец входного потока. - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. - Количество символов в следующей строке больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца потока. - Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. - Количество символов больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. - 1 - - - Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Запись в поток запрещена. - - is null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Значение параметра или — null. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . - Значение true, чтобы заставить сбросить буфер; в противном случае — false. - 1 - - - Получает основной поток, связанный с резервным хранилищем. - Поток, в который StreamWriter выполняет запись. - 2 - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. - 2 - - - Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. - Текущее средство записи закрывается. - Произошла ошибка ввода-вывода. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - 1 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает символ в поток. - Символ, записываемый в поток. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток массив символов. - Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток дочерний массив символов. - Массив символов, содержащий записываемые данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток строку. - Строка, записываемая в поток.Если равняется null, запись не выполняется. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает символ в поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, содержащий записываемые данные. - Положение символа в буфере с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает строку в поток. - Задача, представляющая асинхронную операцию записи. - Строка, записываемая в поток.Если имеет значение null, запись не выполняется. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток признак конца строки. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Реализует класс , осуществляющий чтение из строки. - 2 - - - Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. - Строка, для которой должен быть инициализирован класс . - Значение параметра — null. - - - Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. - Текущее средство чтения закрыто. - 2 - - - Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. - Следующий символ из основной строки или значение -1, если больше нет доступных символов. - Текущее средство чтения закрыто. - 2 - - - Считывает блок символов из строки ввода и увеличивает позицию символов на . - Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Начальный индекс в буфере. - Количество символов, которые необходимо считать. - Параметр имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Следующая строка из текущей строки, или значение null, если достигнут конец строки. - Текущее средство чтения закрыто. - Недостаточно памяти для размещения буфера возвращаемых строк. - 2 - - - Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Содержимое, начиная от текущей позиции до конца основной строки. - Недостаточно памяти для размещения буфера возвращаемых строк. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. - Количество символов больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи данных в строку.Данные хранятся в основном . - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным форматом объекта. - Объект , управляющий форматированием. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . - Класс StringBuilder, в который осуществляется запись. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. - Класс StringBuilder, в который осуществляется запись. - Объект , управляющий форматированием. - Параметр имеет значение null. - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Encoding, в которой осуществляется запись выходных данных. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - - - Возвращает основной . - Базовый StringBuilder. - 2 - - - Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. - Строка, содержащая символы, записанные в текущий StringWriter. - 2 - - - Записывает символ в строку. - Символ для записи. - Средство записи закрыто. - 2 - - - Записывает в строку дочерний массив символов. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Значение параметра или является отрицательным. - ( + )> .Length. - Средство записи закрыто. - 2 - - - Записывает строку в текущую строку. - Строка для записи. - Средство записи закрыто. - 2 - - - Выполняет асинхронную запись символа в строку. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в строку. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текущую строку. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в строку символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Представляет средство чтения, позволяющее считывать последовательные наборы символов. - 2 - - - Инициализирует новый экземпляр класса . - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Предоставляет TextReader без данных, доступных для чтения. - 1 - - - Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. - Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. - При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. - Следующая строка из средства чтения, или значение null, если все символы считаны. - Ошибка ввода-вывода. - Недостаточно памяти для размещения буфера возвращаемых строк. - Объект закрыт. - Количество символов в следующей строке больше . - 1 - - - Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. - Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. - Ошибка ввода-вывода. - Объект закрыт. - Недостаточно памяти для размещения буфера возвращаемых строк. - Количество символов в следующей строке больше . - 1 - - - Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. - Количество символов больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса указанным поставщиком формата. - Объект , управляющий форматированием. - - - Сохраняет символы новой строки, используемые для данного TextWriter. - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. - Кодировка символов, в которой осуществляется запись выходных данных. - 1 - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Удалено средство записи текста. - Средство записи в настоящее время используется предыдущей операцией записи. - - - Возвращает объект, управляющий форматированием. - Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. - 2 - - - Возвращает или задает признак конца строки, используемой текущим TextWriter. - Признак конца строки для текущего TextWriter. - 2 - - - Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись символа в текстовую строку или поток. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись массива символов в текстовую строку или поток. - Массив символов, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает дочерний массив символов в текстовую строку или поток. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает текстовое представление десятичного значения в текстовую строку или поток. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. - Записываемый объект. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает строку в текстовую строку или поток. - Строка для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Параметр или имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет асинхронную запись символа в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись массива символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Записывает признак конца строки в текстовую строку или поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Положение символа в , с которого начинается чтение данных. - Наибольшее количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. - Записываемый объект.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток строку, за которой следует признак конца строки. - Строка для записи.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Строка или объект передаются в виде null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает признак конца строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml deleted file mode 100644 index cf7eb52f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hans/System.IO.xml +++ /dev/null @@ -1,2237 +0,0 @@ - - - - System.IO - - - - 用特定的编码将基元数据类型读作二进制值。 - 2 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输入流。 - 该流不支持读取，为null 或已关闭。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输入流。 - 要使用的字符编码。 - 该流不支持读取，为null 或已关闭。 - - 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输入流。 - 要使用的字符编码。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - 该流不支持读取，为null 或已关闭。 - - 或 为 null。 - - - 公开对 的基础流的访问。 - 与 BinaryReader 关联的基础流。 - 2 - - - 释放 类的当前实例所使用的所有资源。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 用从流中读取的指定字节数填充内部缓冲区。 - 要读取的字节数。 - 在可以读取 之前到达了流的末尾。 - 发生 I/O 错误。 - 请求的 大于内部缓冲区大小。 - - - 返回下一个可用的字符，并且不提升字节或字符的位置。 - 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 - 发生 I/O 错误。 - 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 - 2 - - - 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 输入流中的下一个字符，如果当前无可用字符则为 -1。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 从字节数组中的指定点开始，从流中读取指定的字节数。 - 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字节数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从字符数组中的指定点开始，从流中读取指定的字符数。 - 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字符数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 以压缩格式读入 32 位整数。 - 压缩格式的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 流已损坏。 - - - 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 - 如果字节为非零，则为 true，否则为 false。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的下一个字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 - 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 发生 I/O 错误。 - 流已关闭。 - - 为负数。 - 2 - - - 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 从当前流中读取的字符。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 读取了一个代理项字符。 - 2 - - - 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 - 要读取的字符数。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 流已关闭。 - 发生 I/O 错误。 - - 为负数。 - 2 - - - 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 - 从当前流中读取的十进制数值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的一个有符号字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 4 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 - 正被读取的字符串。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 - 从该流中读取的 2 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 - 从该流中读取的 4 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 - 从该流中读取的 8 字节无符号整数。 - 已到达流的末尾。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 - 2 - - - 初始化向流中写入的 类的新实例。 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输出流。 - 该流不支持写入或者该流已关闭。 - - 为 null。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输出流。 - 要使用的字符编码。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输出流。 - 要使用的字符编码。 - 如果在释放 对象之后打开流对象，则为 true；否则为， false。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 获取 的基础流。 - 与 BinaryWriter 关联的基础流。 - 1 - - - 释放由 类的当前实例占用的所有资源。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 指定无后备存储区的 。 - 1 - - - 持有基础流。 - - - 设置当前流中的位置。 - 包含当前流的位置。 - 相对于 的字节偏移量。 - - 的一个字段，指示获取新位置所依据的参考点。 - 文件指针被移到无效位置。 - - 值无效。 - 1 - - - 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 - 要写入的 Boolean 值（0 或 1）。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的无符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将字节数组写入基础流。 - 包含要写入的数据的字节数组。 - 发生 I/O 错误。 - 流已关闭。 - - 为 null。 - 1 - - - 将字节数组部分写入当前流。 - 包含要写入的数据的字节数组。 - - 中开始写入的起始点。 - 要写入的字节数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 要写入的非代理项 Unicode 字符。 - 发生 I/O 错误。 - 流已关闭。 - - 是单一代理项字符。 - 1 - - - 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 为 null。 - 流已关闭。 - 发生 I/O 错误。 - 1 - - - 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 中开始写入的起始点。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个十进制值写入当前流，并将流位置提升十六个字节。 - 要写入的十进制值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的有符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 - 要写入的值。 - 发生 I/O 错误。 - - 为 null。 - 流已关闭。 - 1 - - - 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 以压缩格式写出 32 位整数。 - 要写出的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 流已关闭。 - - - 读操作试图超出流的末尾时引发的异常。 - 2 - - - 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - - - 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - - - 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 在数据流的格式无效时引发的异常。 - - - 初始化 类的新实例。 - - - 使用指定的错误消息初始化 类的新实例。 - 解释异常原因的错误信息。 - - - 用对作为此异常原因的内部异常的引用初始化 类的新实例。 - 解释异常原因的错误信息。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化为零的可扩展容量初始化 类的新实例。 - - - 基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建当前流的无符号字节数组。 - - 为 null。 - - - 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - - 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 为 null。 - - 或 小于零。 - 缓冲区长度减去 小于 。 - - - 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 使用按指定要求初始化的可扩展容量初始化 类的新实例。 - 内部数组的初始大小（以字节为单位）。 - - 为负数。 - - - 获取一个值，该值指示当前流是否支持读取。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持查找。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持写入。 - 如果流支持写入，则为 true；否则为 false。 - 2 - - - 获取或设置分配给该流的字节数。 - 流的缓冲区的可使用部分的长度。 - 容量设置为负或小于流的当前长度。 - 当前流已关闭。 - 对不能修改其容量的流调用 set。 - 2 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。 - 要监视取消请求的标记。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 重写 方法以便不执行任何操作。 - 2 - - - 异步清除此流的所有缓冲区，并监视取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。 - 流已被释放。 - - - 获取流的长度（以字节为单位）。 - 流的长度（以字节为单位）。 - 流已关闭。 - 2 - - - 获取或设置流中的当前位置。 - 流中的当前位置。 - 此位置设置为负值或大于 的值。 - 流已关闭。 - 2 - - - 从当前流中读取字节块并将数据写入缓冲区。 - 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 - 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 - - 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 的结果小于 。 - 当前流实例已关闭。 - 2 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流中读取一个字节。 - 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 - 当前流实例已关闭。 - 2 - - - 将当前流中的位置设置为指定值。 - 流内的新位置，通过将初始引用点和偏移量合并计算而得。 - 流内的新位置。它是相对于 参数的位置，而且可正可负。 - 类型 的值，它用作查找引用点。 - 试图在流的开始位置之前查找。 - - 大于 。 - - 无效。- 或 - 导致算法溢出。 - 当前流实例已关闭。 - 2 - - - 将当前流的长度设为指定值。 - 用于设置长度的值。 - 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 - - 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 - 2 - - - 将流内容写入字节数组，而与 属性无关。 - 新的字节数组。 - 2 - - - 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 - 如果转换成功，则为 true；否则为 false。 - 用于创建此流的字节数组段。 - - - 使用从缓冲区读取的数据将字节块写入当前流。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 最多写入的字节数。 - - 为 null。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 - 缓冲区长度减去 的结果小于 。 - - 或 为负。 - 发生 I/O 错误。 - 当前流实例已关闭。 - 2 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入当前位置上的当前流。 - 要写入的字节。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 - 当前流已关闭。 - 2 - - - 将此内存流的整个内容写入到另一个流中。 - 要写入此内存流的流。 - - 为 null。 - 当前流或目标流已关闭。 - 2 - - - 指定在流的位置以查找使用。 - 2 - - - 指定流的开头。 - - - 指定流内的当前位置。 - - - 指定流的结尾。 - - - 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 类的新实例。 - - - 当在派生类中重写时，获取指示当前流是否支持读取的值。 - 如果流支持读取，为 true；否则为 false。 - 1 - - - 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 - 如果流支持查找，为 true；否则为 false。 - 1 - - - 获取一个值，该值确定当前流是否可以超时。 - 一个确定当前流是否可以超时的值。 - 2 - - - 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 - 如果流支持写入，则为 true；否则为 false。 - 1 - - - 从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - 缓冲区的大小。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放由 使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 - 发生 I/O 错误。 - 2 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。默认值为 。 - 流已被释放。 - - - 当在派生类中重写时，获取流长度（以字节为单位）。 - 表示流长度（以字节为单位）的长值。 - 从 Stream 派生的类不支持查找。 - 在流关闭后调用方法。 - 1 - - - 无后备存储区的 Stream。 - 1 - - - 当在派生类中重写时，获取或设置当前流中的位置。 - 流中的当前位置。 - 发生 I/O 错误。 - 流不支持查找。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 - 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 - 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 - - 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 - 要从当前流中最多读取的字节数。 - - 与 的和大于缓冲区长度。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流不支持读取。 - 在流关闭后调用方法。 - 1 - - - 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 - 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 - 流不支持读取。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 - 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 当在派生类中重写时，设置当前流中的位置。 - 当前流中的新位置。 - 相对于 参数的字节偏移量。 - - 类型的值，指示用于获取新位置的参考点。 - 发生 I/O 错误。 - 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，设置当前流的长度。 - 所需的当前流的长度（以字节表示）。 - 发生 I/O 错误。 - 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 2 - - - 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 - 字节数组。此方法将 个字节从 复制到当前流。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 要写入当前流的字节数。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 流不支持写入。 - - 流关闭后调用。 - 1 - - - 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 - 要写入流中的字节。 - 发生 I/O 错误。 - 该流不支持写入，或者该流已关闭。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 - 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 为指定的流初始化 类的新实例。 - 要读取的流。 - - 不支持读取。 - - 为 null。 - - - 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 - 要读取的流。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 为 null。 - - - 用指定的字符编码为指定的流初始化 类的一个新实例。 - 要读取的流。 - 要使用的字符编码。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - 最小缓冲区大小。 - 流不支持读取。 - - 或 为 null。 - - 小于或等于零。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 - 要读取的流。 - 要使用的字符编码。 - 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 - 最小缓冲区大小。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - - - 返回基础流。 - 基础流。 - 2 - - - 获取当前 对象正在使用的当前字符编码。 - 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 - 2 - - - 清除内部缓冲区。 - 2 - - - 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 获取一个值，该值指示当前的流位置是否在流结尾。 - 如果当前流位置位于流的末尾，则为 true；否则为 false。 - 基础流已释放。 - 1 - - - 空流周围的 。 - 1 - - - 返回下一个可用字符，但不使用它。 - 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 - 发生 I/O 错误。 - 1 - - - 读取输入流中的下一个字符并使该字符位置提升一个字符。 - 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 - 发生 I/O 错误。 - 1 - - - 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 - 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 开始写入的 的索引。 - 要读取的最大字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 出现 I/O 错误，如流被关闭。 - 1 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生了 I/O 错误。 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取一行字符并将数据作为字符串返回。 - 输入流中的下一行；如果到达了输入流的末尾，则为 null。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 从当前流中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 - 下一行中的字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取来自流的当前位置到结尾的所有字符。 - 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 - 字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 - 1 - - - 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 - 要写入的流。 - - 不可写。 - - 为 null。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - - 或 为 null。 - - 不可写。 - - - 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - true to leave the stream open after the object is disposed; otherwise, false. - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 - 强制 刷新其缓冲区时，为 true；否则，为 false。 - 1 - - - 获取同后备存储连接的基础流。 - 此 StreamWriter 正在写入的基础流。 - 2 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - 当前编码不支持显示半个 Unicode 代理项对。 - - - 获取将输出写入到其中的 。 - 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 - 2 - - - 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 - 当前编写器已关闭。 - 出现 I/O 错误。 - 当前编码不支持显示半个 Unicode 代理项对。 - 1 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将字符写入流。 - 要写入流中的字符。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符数组写入流。 - 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符的子数组写入流。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符串写入流。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 发生 I/O 错误。 - 1 - - - 将字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将行终止符异步写入该流。 - 表示异步写操作的任务。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 实现从字符串进行读取的 。 - 2 - - - 初始化从指定字符串进行读取的 类的新实例。 - 应将 初始化为的字符串。 - - 参数为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 返回下一个可用的字符，但不使用它。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 - 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的字符块，并将字符位置提升 。 - 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 缓存区中的起始索引。 - 要读取的字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 当前读取器已关闭。 - 2 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前字符串中读取一行字符并将数据作为字符串返回。 - 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 - 当前读取器已关闭。 - 内存不足，无法为返回的字符串分配缓冲区。 - 2 - - - 从当前字符串中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 从当前位置到基础字符串的结尾之间的内容。 - 内存不足，无法为返回的字符串分配缓冲区。 - 当前读取器已关闭。 - 2 - - - 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 - 字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式控制初始化 类的新实例。 - 控制格式设置的 对象。 - - - 初始化写入指定 的 类的新实例。 - 要写入的 StringBuilder。 - - 为 null。 - - - 初始化写入指定 并具有指定格式提供程序的 类的新实例。 - 要写入的 StringBuilder。 - 控制格式设置的 对象。 - - 为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 获取将输出写入到其中的 。 - 用来写入输出的 Encoding。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - - - 返回基础 。 - 基础 StringBuilder。 - 2 - - - 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 - 包含写入到当前 StringWriter 中的字符的字符串。 - 2 - - - 将字符写入该字符串。 - 要写入的字符。 - 编写器已关闭。 - 2 - - - 将字符的子数组写入该字符串。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - 或 为负。 - ( + )> 。Length. - 编写器已关闭。 - 2 - - - 将字符串写入当前流。 - 要写入的字符串。 - 编写器已关闭。 - 2 - - - 以异步方式将字符写入流。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将字符串写入当前流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将后跟行结束符的字符写入该字符串。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将一后跟行结束符的字符串异步写入当前字符串。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 表示可读取有序字符系列的读取器。 - 2 - - - 初始化 类的新实例。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - 提供一个无数据可供读取的 TextReader。 - 1 - - - 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 - 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 - 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 2 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从文本读取器中读取一行字符并将数据作为字符串返回。 - 读取器中的下一行，或为 null （如果已读取了所有字符）。 - 发生 I/O 错误。 - 内存不足，无法为返回的字符串分配缓冲区。 - - 是关闭的。 - 下一行中的字符数大于 - 1 - - - 异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 - 发生 I/O 错误。 - - 是关闭的。 - 内存不足，无法为返回的字符串分配缓冲区。 - 下一行中的字符数大于 - 1 - - - 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 - 字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 表示可以编写一个有序字符系列的编写器。此类为抽象类。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式提供程序初始化 类的新实例。 - 控制格式设置的 对象。 - - - 存储用于此 TextWriter 的换行符。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，返回用来写输出的该字符编码。 - 用来写入输出的字符编码。 - 1 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - 文本编写器已被释放。 - 编写器正在由其前一次写操作使用。 - - - 获取控制格式设置的对象。 - 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 - 2 - - - 获取或设置由当前 TextWriter 使用的行结束符字符串。 - 当前 TextWriter 的行结束符字符串。 - 2 - - - 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符写入该文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符数组写入该文本字符串或流。 - 要写入文本流中的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符的子数组写入文本字符串或流。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符串写入到文本字符串或流。 - 要写入的字符串。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - - 或 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符写入到下一个文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符数组写入到下一个字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符串写入到下一字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将行结束符的字符串写入文本字符串或流。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符写入文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符数组写入文本字符串或流。 - 从其读取数据的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符子数组写入文本字符串或流。 - 从其读取数据的字符数组。 - 在开始读取数据时 中的字符位置。 - 要写入的最大字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符串写入文本字符串或流。 - 要写入的字符串。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - 字符串或对象作为 null 传入。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml deleted file mode 100644 index 26192a9d..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.0/zh-hant/System.IO.xml +++ /dev/null @@ -1,2246 +0,0 @@ - - - - System.IO - - - - 以特定的編碼方式，將基本資料型別當做二進位值讀取。 - 2 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸入資料流。 - 資料流不支援讀取，為 null，或已經關閉。 - - - 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 - 輸入資料流。 - 要使用的字元編碼。 - 資料流不支援讀取，為 null，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 - 輸入資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - 資料流不支援讀取，為 null，或已經關閉。 - - 或 為 null。 - - - 公開 之基礎資料流的存取。 - 與 BinaryReader 相關聯的基礎資料流。 - 2 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 將從資料流讀取的指定位元組數目填入內部緩衝區。 - 要讀取的位元組數。 - 在 可讀取之前到達資料流末端。 - 發生 I/O 錯誤。 - 所要求的 大於內部緩衝區大小。 - - - 傳回下一個可用字元，而不前移位元組或字元的位置。 - 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 - 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 - 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的位元組數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 由字元陣列中的指定點開始，從資料流讀取指定字元數。 - 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的字元數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以壓縮格式讀取 32 位元整數。 - 壓縮格式的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 資料流已損毀。 - - - 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 - 如果位元組為非零值，則為 true；否則為 false。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 - 自目前資料流讀取的下一個位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 - 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 - 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為負值。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 - 自目前資料流讀取的字元。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 讀取到 Surrogate 字元 - 2 - - - 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 - 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 - 要讀取的字元數。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 已關閉資料流。 - 發生 I/O 錯誤。 - - 為負值。 - 2 - - - 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 - 自目前資料流讀取的十進位值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自目前資料流讀取的 2 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 - 自資料流讀取的帶正負號的位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 - 讀取的字串。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自這個資料流讀取 2 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自這個資料流讀取 4 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自這個資料流讀取 8 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 - 2 - - - 初始化 類別的新執行個體，其將寫入資料流。 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 資料流不支援寫入，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 要使用的字元編碼。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 輸出資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 取得 的基礎資料流。 - 與 BinaryWriter 相關聯的基礎資料流。 - 1 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 指定沒有備份存放區的 。 - 1 - - - 容納基礎資料流。 - - - 設定目前資料流位置。 - 目前資料流的位置。 - 相對於 的位元組位移。 - - 的欄位，表示要取得新位置的參考點。 - 檔案指標已移至無效的位置。 - - 值是無效的。 - 1 - - - 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 - 要寫入的 Boolean 值 (0 或 1)。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的不帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將位元組陣列寫入基礎資料流。 - 含有要寫入之資料的位元組陣列。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為 null。 - 1 - - - 將一個區域的位元組陣列寫入目前資料流。 - 含有要寫入之資料的位元組陣列。 - - 中要開始寫入的起始點。 - 要寫入的位元組數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 非 Surrogate，要寫入的 Unicode 字元。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 是單一 Surrogate 字元。 - 1 - - - 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 為 null。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 中要開始寫入的起始點。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 - 要寫入的十進位值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 要寫入的值。 - 發生 I/O 錯誤。 - - 為 null。 - 已關閉資料流。 - 1 - - - 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組不帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 以壓縮格式寫入 32 位元整數。 - 要寫入的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 已關閉資料流。 - - - 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 - 2 - - - 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - - - 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - - - 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 資料流在格式無效時擲回的例外狀況。 - - - 初始化 類別的新執行個體。 - - - 使用指定的錯誤訊息，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - - - 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 - - - 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 - 用於建立目前資料流之不帶正負號位元組的陣列。 - - 為 null。 - - - 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - - 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 為 null。 - - 或 小於零。 - 緩衝區長度減去 小於 。 - - - 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 - 內部陣列的初始大小，以位元組為單位。 - - 為負值。 - - - 取得表示目前資料流是否支援讀取的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援搜尋的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援寫入的值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 2 - - - 取得或設定配置給這個資料流的位元組數目。 - 資料流緩衝區可使用部分的長度。 - 設定的容量為負數或小於資料流目前的長度。 - 目前的資料流已經關閉。 - set 在無法修改其容量的資料流上被叫用 (Invoke)。 - 2 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 - 用來監視是否有取消要求的語彙基元。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 覆寫 方法，以便不執行任何動作。 - 2 - - - 非同步清除這個資料流的所有緩衝區，並監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。 - 已處置資料流。 - - - 取得資料流的長度，以位元組為單位。 - 資料流的長度，以位元組為單位。 - 已關閉資料流。 - 2 - - - 取得或設定資料流中目前的位置。 - 在資料流的目前位置。 - 位置設為負數值或大於 的值。 - 已關閉資料流。 - 2 - - - 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 - 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 - - 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - 緩衝區的長度減去 小於 。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從目前的資料流讀取位元組。 - 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流中的位置設定為指定的數值。 - 資料流中的新位置，是組合初始的參考點和位移計算出來的。 - 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 - - 類型的值，做為搜尋參考點。 - 在資料流開頭之前嘗試搜尋。 - - 大於 。 - 有無效的 。-或- 造成了算術溢位。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流的長度設定為指定的數值。 - 要設定長度的數值。 - 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 - - 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 - 2 - - - 不論 屬性為何，將資料流內容寫入位元組陣列。 - 新的位元組陣列。 - 2 - - - 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 - 如果轉換成功，則為 true；否則為 false。 - 從其中建立此資料流的位元組陣列區段。 - - - 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入的最大位元組數。 - - 為 null。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 - 緩衝區的長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入位元組至資料流目前位置。 - 要寫入的位元組。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 - 目前的資料流已經關閉。 - 2 - - - 將這個記憶體資料流的整個內容寫入另一個資料流。 - 要寫入這個記憶體資料流的資料流。 - - 為 null。 - 目前的資料流或目標資料流已經關閉。 - 2 - - - 指定資料流中要用於搜尋的位置。 - 2 - - - 指定資料流的開端。 - - - 指定資料流中的目前位置。 - - - 指定資料流的末端。 - - - 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 類別的新執行個體。 - - - 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 - 如果資料流支援讀取，則為 true；否則為 false。 - 1 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 - 如果資料流支援搜尋，則為 true；否則為 false。 - 1 - - - 取得值，該值判斷目前的資料流是否可以逾時。 - 值，判斷目前的資料流是否可以逾時。 - 2 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 1 - - - 從目前資料流讀取位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 所使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 發生 I/O 錯誤。 - 2 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 已處置資料流。 - - - 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - 已處置資料流。 - - - 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 - 代表資料流長度的長數值 (以位元組為單位)。 - 衍生自 Stream 的類別不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 沒有底層存放區的 Stream。 - 1 - - - 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 - 在資料流的目前位置。 - 發生 I/O 錯誤。 - 資料流不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 - 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 - 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 - - 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 - 自目前資料流讀取的最大位元組數。 - - 和 的總和大於緩衝區的長度。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 - 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - - 方法必須擲回 。 - 2 - - - 在衍生類別中覆寫時，設定在目前資料流的位置。 - 目前資料流的新位置。 - 相對於 參數的位元組位移。 - - 類型的值，表示用來取得新位置的參考點。 - 發生 I/O 錯誤。 - 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 在衍生類別中覆寫時，設定目前資料流的長度。 - 想要的目前資料流長度 (單位為位元組)。 - 發生 I/O 錯誤。 - 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 - 位元組陣列。此方法會從 複製 位元組到目前資料流。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入目前資料流的位元組數目。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 資料流不支援寫入。 - - 流关闭后调用。 - 1 - - - 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 - 寫入資料流的位元組。 - 發生 I/O 錯誤。 - 資料流不支援寫入，或資料流已經關閉。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - - 方法必須擲回 。 - 2 - - - 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 為指定的資料流，初始化 類別的新執行個體。 - 要讀取的資料流。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - 最小緩衝區大小。 - 資料流不支援讀取。 - - 或 為 null。 - - 小於或等於零值。 - - - 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要讀取的資料流。 - 要使用的字元編碼。 - true 表示在檔案開頭尋找位元順序標記；否則為 false。 - 最小緩衝區大小。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - - - 傳回基礎資料流。 - 基礎資料流。 - 2 - - - 取得目前 物件使用的目前字元編碼。 - 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 - 2 - - - 清除內部緩衝區。 - 2 - - - 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得表示現行資料流位置是否在資料流結尾的值。 - 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 - 已處置基礎資料流。 - 1 - - - 空資料流周圍的 物件。 - 1 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 1 - - - 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 - 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 - 發生 I/O 錯誤。 - 1 - - - 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 - 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - 要開始寫入的 的索引。 - 要讀取的字元數上限。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤，例如資料流已經關閉。 - 1 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前資料流讀取一行字元，並將資料以字串傳回。 - 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 - 下一行中的字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到資料流末端的所有字元。 - 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 - 字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 - 1 - - - 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - - 不可寫入。 - - 為 null。 - - - 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - - 或 是 null。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 - 強制 清除其緩衝區，則為 true，否則為 false。 - 1 - - - 取得以備份存放區作介面的基礎資料流。 - StreamWriter 正在寫入的資料流。 - 2 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - - - 取得寫入輸出的 。 - - (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 - 2 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 - 目前寫入器已關閉。 - 發生 I/O 錯誤。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - 1 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - 已處置資料流。 - - - 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將一個字元寫入資料流。 - 要寫入資料流的字元。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元陣列寫入資料流。 - 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元子陣列寫入資料流。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字串寫入資料流。 - 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入資料流。 - 表示非同步寫入作業的工作。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 將行結束字元以非同步方式寫入資料流。 - 表示非同步寫入作業的工作。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 實作讀取字串的 。 - 2 - - - 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 - - 應該初始化的目的字串。 - - 參數為 null。 - - - 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 - 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 - 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - 緩衝區中的起始索引。 - 要讀取的字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負數。 - 目前的讀取器已關閉。 - 2 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前字串讀取一行字元，並將資料以字串傳回。 - 目前字串的下一行，如果已到達字串的結尾，則為 null。 - 目前的讀取器已關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 2 - - - 自目前字串非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 基礎字串從目前位置至結尾的內容。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 目前的讀取器已關閉。 - 2 - - - 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 - 字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的控制項格式，初始化 類別的新執行個體。 - 控制格式的 物件。 - - - 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 - 要寫入至其中的 StringBuilder。 - - 為 null。 - - - 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 - 要寫入至其中的 StringBuilder。 - 控制格式的 物件。 - - 為 null。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得寫入輸出的 。 - 寫入輸出的 Encoding。 - 1 - - - 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - - - 傳回基礎 。 - 基礎 StringBuilder。 - 2 - - - 傳回字串，包含被寫入至目前 StringWriter 的字元。 - 字串，包含被寫入至目前 StringWriter 的字元。 - 2 - - - 將一個字元寫入至字串。 - 要寫入的字元。 - 寫入器關閉。 - 2 - - - 將字元子陣列寫入至字串。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 或 為負數。 - ( + )> 。Length. - 寫入器關閉。 - 2 - - - 將字串寫入至目前字串。 - 要寫入的字串。 - 寫入器關閉。 - 2 - - - 以非同步方式將字元寫入至字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入至字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入至目前字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 代表可以讀取一連串連續字元的讀取器 (Reader)。 - 2 - - - 初始化 類別的新執行個體。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 提供未讀取資料的 TextReader。 - 1 - - - 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 - 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 2 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自文字讀取器讀取一行字元，並將資料以字串傳回。 - 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 - 發生 I/O 錯誤。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - - 已經關閉。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 字串，包含從目前位置到文字讀取器結尾的所有字元。 - 發生 I/O 錯誤。 - - 已經關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 - 字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的格式提供者，初始化 類別的新執行個體。 - 控制格式設定的 物件。 - - - 儲存這個 TextWriter 所使用的新行字元。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 - 寫入輸出時使用的字元編碼。 - 1 - - - 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 文字寫入器已處置。 - 寫入器目前由先前寫入作業所使用。 - - - 取得控制格式設定的物件。 - 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 - 2 - - - 取得或設定目前 TextWriter 所使用的行結束字元字串。 - 目前 TextWriter 的行結束字元字串。 - 2 - - - 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將 Boolean 值的文字表示寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列寫入到文字字串或資料流。 - 要寫入到文字資料流的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元的子陣列寫入到文字字串或資料流。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 - 要寫入的物件。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串寫入到文字字串或資料流。 - 要寫入的字串。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - - 或 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 將行結束字元寫入到文字字串或資料流。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 中開始讀取資料的字元位置。 - 要寫入的最大字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的物件。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入的字串。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - 傳入的字串或物件為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將行結束字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.3/System.IO.dll deleted file mode 100644 index 4bc64f3928aedae16e08170388511348dbf676e2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29864 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�$pQO;0L%zP?$;33|s|xiPHa)JnRw5;{9V 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 Wp1$q6S?`&3-GH>3>Qxc2ZvH - - - System.IO - - - - Reads primitive data types as binary values in a specific encoding. - 2 - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The input stream. - The stream does not support reading, is null, or is already closed. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The input stream. - The character encoding to use. - The stream does not support reading, is null, or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The input stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support reading, is null, or is already closed. - - or is null. - - - Exposes access to the underlying stream of the . - The underlying stream associated with the BinaryReader. - 2 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Fills the internal buffer with the specified number of bytes read from the stream. - The number of bytes to be read. - The end of the stream is reached before could be read. - An I/O error occurs. - Requested is larger than the internal buffer size. - - - Returns the next available character and does not advance the byte or character position. - The next available character, or -1 if no more characters are available or the stream does not support seeking. - An I/O error occurs. - The current character cannot be decoded into the internal character buffer by using the selected for the stream. - 2 - - - Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - The next character from the input stream, or -1 if no characters are currently available. - An I/O error occurs. - The stream is closed. - 2 - - - Reads the specified number of bytes from the stream, starting from a specified point in the byte array. - The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of bytes to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of characters from the stream, starting from a specified point in the character array. - The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of characters to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads in a 32-bit integer in compressed format. - A 32-bit integer in compressed format. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - The stream is corrupted. - - - Reads a Boolean value from the current stream and advances the current position of the stream by one byte. - true if the byte is nonzero; otherwise, false. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the next byte from the current stream and advances the current position of the stream by one byte. - The next byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. - A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. - The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - An I/O error occurs. - The stream is closed. - - is negative. - 2 - - - Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - A character read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - A surrogate character was read. - 2 - - - Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. - A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. - The number of characters to read. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - The stream is closed. - An I/O error occurs. - - is negative. - 2 - - - Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. - A decimal value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. - An 8-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. - A 2-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. - A 4-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. - An 8-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a signed byte from this stream and advances the current position of the stream by one byte. - A signed byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. - A 4-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. - The string being read. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. - A 2-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. - A 4-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. - An 8-byte unsigned integer read from this stream. - The end of the stream is reached. - An I/O error occurs. - The stream is closed. - 2 - - - Writes primitive types in binary to a stream and supports writing strings in a specific encoding. - 2 - - - Initializes a new instance of the class that writes to a stream. - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The output stream. - The stream does not support writing or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The output stream. - The character encoding to use. - The stream does not support writing or is already closed. - - or is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The output stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support writing or is already closed. - - or is null. - - - Gets the underlying stream of the . - The underlying stream associated with the BinaryWriter. - 1 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Specifies a with no backing store. - 1 - - - Holds the underlying stream. - - - Sets the position within the current stream. - The position with the current stream. - A byte offset relative to . - A field of indicating the reference point from which the new position is to be obtained. - The file pointer was moved to an invalid location. - The value is invalid. - 1 - - - Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. - The Boolean value to write (0 or 1). - An I/O error occurs. - The stream is closed. - 1 - - - Writes an unsigned byte to the current stream and advances the stream position by one byte. - The unsigned byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a byte array to the underlying stream. - A byte array containing the data to write. - An I/O error occurs. - The stream is closed. - - is null. - 1 - - - Writes a region of a byte array to the current stream. - A byte array containing the data to write. - The starting point in at which to begin writing. - The number of bytes to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - The non-surrogate, Unicode character to write. - An I/O error occurs. - The stream is closed. - - is a single surrogate character. - 1 - - - Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - A character array containing the data to write. - - is null. - The stream is closed. - An I/O error occurs. - 1 - - - Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. - A character array containing the data to write. - The starting point in from which to begin writing. - The number of characters to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a decimal value to the current stream and advances the stream position by sixteen bytes. - The decimal value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. - The eight-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. - The two-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. - The four-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. - The eight-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a signed byte to the current stream and advances the stream position by one byte. - The signed byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. - The four-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. - The value to write. - An I/O error occurs. - - is null. - The stream is closed. - 1 - - - Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. - The two-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. - The four-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. - The eight-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a 32-bit integer in a compressed format. - The 32-bit integer to be written. - The end of the stream is reached. - The stream is closed. - The stream is closed. - - - The exception that is thrown when reading is attempted past the end of a stream. - 2 - - - Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. - - - Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - - - Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - The exception that is thrown when a data stream is in an invalid format. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with a specified error message. - The error message that explains the reason for the exception. - - - Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. - The error message that explains the reason for the exception. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class with an expandable capacity initialized to zero. - - - Initializes a new non-resizable instance of the class based on the specified byte array. - The array of unsigned bytes from which to create the current stream. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. - The array of unsigned bytes from which to create this stream. - The setting of the property, which determines whether the stream supports writing. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - - is null. - - or is less than zero. - The buffer length minus is less than . - - - Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. - The array of unsigned bytes from which to create this stream. - The index in at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - - is null. - - or are negative. - The buffer length minus is less than . - - - Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. - - is null. - - or is negative. - The buffer length minus is less than . - - - Initializes a new instance of the class with an expandable capacity initialized as specified. - The initial size of the internal array in bytes. - - is negative. - - - Gets a value indicating whether the current stream supports reading. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports seeking. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 2 - - - Gets or sets the number of bytes allocated for this stream. - The length of the usable portion of the buffer for the stream. - A capacity is set that is negative or less than the current length of the stream. - The current stream is closed. - set is invoked on a stream whose capacity cannot be modified. - 2 - - - Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. - The token to monitor for cancellation requests. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Overrides the method so that no action is performed. - 2 - - - Asynchronously clears all buffers for this stream, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. - The stream has been disposed. - - - Gets the length of the stream in bytes. - The length of the stream in bytes. - The stream is closed. - 2 - - - Gets or sets the current position within the stream. - The current position within the stream. - The position is set to a negative value or a value greater than . - The stream is closed. - 2 - - - Reads a block of bytes from the current stream and writes the data to a buffer. - The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. - When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. - The zero-based byte offset in at which to begin storing data from the current stream. - The maximum number of bytes to read. - - is null. - - or is negative. - - subtracted from the buffer length is less than . - The current stream instance is closed. - 2 - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the current stream. - The byte cast to a , or -1 if the end of the stream has been reached. - The current stream instance is closed. - 2 - - - Sets the position within the current stream to the specified value. - The new position within the stream, calculated by combining the initial reference point and the offset. - The new position within the stream. This is relative to the parameter, and can be positive or negative. - A value of type , which acts as the seek reference point. - Seeking is attempted before the beginning of the stream. - - is greater than . - There is an invalid . -or- caused an arithmetic overflow. - The current stream instance is closed. - 2 - - - Sets the length of the current stream to the specified value. - The value at which to set the length. - The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. - - is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. - 2 - - - Writes the stream contents to a byte array, regardless of the property. - A new byte array. - 2 - - - Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. - true if the conversion was successful; otherwise, false. - The byte array segment from which this stream was created. - - - Writes a block of bytes to the current stream using data read from a buffer. - The buffer to write data from. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The maximum number of bytes to write. - - is null. - The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. - - subtracted from the buffer length is less than . - - or are negative. - An I/O error occurs. - The current stream instance is closed. - 2 - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current stream at the current position. - The byte to write. - The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. - The current stream is closed. - 2 - - - Writes the entire contents of this memory stream to another stream. - The stream to write this memory stream to. - - is null. - The current or target stream is closed. - 2 - - - Specifies the position in a stream to use for seeking. - 2 - - - Specifies the beginning of a stream. - - - Specifies the current position within a stream. - - - Specifies the end of a stream. - - - Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class. - - - When overridden in a derived class, gets a value indicating whether the current stream supports reading. - true if the stream supports reading; otherwise, false. - 1 - - - When overridden in a derived class, gets a value indicating whether the current stream supports seeking. - true if the stream supports seeking; otherwise, false. - 1 - - - Gets a value that determines whether the current stream can time out. - A value that determines whether the current stream can time out. - 2 - - - When overridden in a derived class, gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 1 - - - Reads the bytes from the current stream and writes them to another stream. - The stream to which the contents of the current stream will be copied. - - is null. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - The stream to which the contents of the current stream will be copied. - The size of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Asynchronously reads the bytes from the current stream and writes them to another stream. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - - is null. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - The token to monitor for cancellation requests. The default value is . - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases all resources used by the . - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. - An I/O error occurs. - 2 - - - Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. The default value is . - The stream has been disposed. - - - When overridden in a derived class, gets the length in bytes of the stream. - A long value representing the length of the stream in bytes. - A class derived from Stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - A Stream with no backing store. - 1 - - - When overridden in a derived class, gets or sets the position within the current stream. - The current position within the stream. - An I/O error occurs. - The stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - The sum of and is larger than the buffer length. - - is null. - - or is negative. - An I/O error occurs. - The stream does not support reading. - Methods were called after the stream was closed. - 1 - - - Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. - The unsigned byte cast to an Int32, or -1 if at the end of the stream. - The stream does not support reading. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. - A value, in miliseconds, that determines how long the stream will attempt to read before timing out. - The method always throws an . - 2 - - - When overridden in a derived class, sets the position within the current stream. - The new position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - An I/O error occurs. - The stream does not support seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - An I/O error occurs. - The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 2 - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - The sum of  and  is greater than the buffer length. - - is null. - - or  is negative. - An I/O error occured, such as the specified file cannot be found. - The stream does not support writing. - - was called after the stream was closed. - 1 - - - Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current position in the stream and advances the position within the stream by one byte. - The byte to write to the stream. - An I/O error occurs. - The stream does not support writing, or the stream is already closed. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. - A value, in miliseconds, that determines how long the stream will attempt to write before timing out. - The method always throws an . - 2 - - - Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream. - The stream to be read. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. - The stream to be read. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding. - The stream to be read. - The character encoding to use. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - The minimum buffer size. - The stream does not support reading. - - or is null. - - is less than or equal to zero. - - - Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. - The stream to read. - The character encoding to use. - true to look for byte order marks at the beginning of the file; otherwise, false. - The minimum buffer size. - true to leave the stream open after the object is disposed; otherwise, false. - - - Returns the underlying stream. - The underlying stream. - 2 - - - Gets the current character encoding that the current object is using. - The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. - 2 - - - Clears the internal buffer. - 2 - - - Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets a value that indicates whether the current stream position is at the end of the stream. - true if the current stream position is at the end of the stream; otherwise false. - The underlying stream has been disposed. - 1 - - - A object around an empty stream. - 1 - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. - An I/O error occurs. - 1 - - - Reads the next character from the input stream and advances the character position by one character. - The next character from the input stream represented as an object, or -1 if no more characters are available. - An I/O error occurs. - 1 - - - Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. - The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The index of at which to begin writing. - The maximum number of characters to read. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs, such as the stream is closed. - 1 - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurred. - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current stream and returns the data as a string. - The next line from the input stream, or null if the end of the input stream is reached. - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads a line of characters asynchronously from the current stream and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the stream. - The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. - The number of characters is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. - The stream to write to. - - is not writable. - - is null. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. - The stream to write to. - The character encoding to use. - - or is null. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - - or is null. - - is negative. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - true to leave the stream open after the object is disposed; otherwise, false. - - or is null. - - is negative. - - is not writable. - - - Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . - true to force to flush its buffer; otherwise, false. - 1 - - - Gets the underlying stream that interfaces with a backing store. - The stream this StreamWriter is writing to. - 2 - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - The current encoding does not support displaying half of a Unicode surrogate pair. - - - Gets the in which the output is written. - The specified in the constructor for the current instance, or if an encoding was not specified. - 2 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. - The current writer is closed. - An I/O error has occurred. - The current encoding does not support displaying half of a Unicode surrogate pair. - 1 - - - Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Provides a StreamWriter with no backing store that can be written to, but not read from. - 1 - - - Writes a character to the stream. - The character to write to the stream. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a character array to the stream. - A character array containing the data to write. If is null, nothing is written. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a subarray of characters to the stream. - A character array that contains the data to write. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The buffer length minus is less than . - - or is negative. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a string to the stream. - The string to write to the stream. If is null, nothing is written. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - An I/O error occurs. - 1 - - - Writes a character to the stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the stream asynchronously. - A task that represents the asynchronous write operation. - A character array that contains the data to write. - The character position in the buffer at which to begin reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string to the stream asynchronously. - A task that represents the asynchronous write operation. - The string to write to the stream. If is null, nothing is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Implements a that reads from a string. - 2 - - - Initializes a new instance of the class that reads from the specified string. - The string to which the should be initialized. - The parameter is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. - The current reader is closed. - 2 - - - Reads the next character from the input string and advances the character position by one character. - The next character from the underlying string, or -1 if no more characters are available. - The current reader is closed. - 2 - - - Reads a block of characters from the input string and advances the character position by . - The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The starting index in the buffer. - The number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The current reader is closed. - 2 - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current string and returns the data as a string. - The next line from the current string, or null if the end of the string is reached. - The current reader is closed. - There is insufficient memory to allocate a buffer for the returned string. - 2 - - - Reads a line of characters asynchronously from the current string and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the string and returns them as a single string. - The content from the current position to the end of the underlying string. - There is insufficient memory to allocate a buffer for the returned string. - The current reader is closed. - 2 - - - Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. - The number of characters is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing information to a string. The information is stored in an underlying . - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format control. - An object that controls formatting. - - - Initializes a new instance of the class that writes to the specified . - The StringBuilder to write to. - - is null. - - - Initializes a new instance of the class that writes to the specified and has the specified format provider. - The StringBuilder to write to. - An object that controls formatting. - - is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets the in which the output is written. - The Encoding in which the output is written. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - - - Returns the underlying . - The underlying StringBuilder. - 2 - - - Returns a string containing the characters written to the current StringWriter so far. - The string containing the characters written to the current StringWriter. - 2 - - - Writes a character to the string. - The character to write. - The writer is closed. - 2 - - - Writes a subarray of characters to the string. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - - or is negative. - ( + )> . Length. - The writer is closed. - 2 - - - Writes a string to the current string. - The string to write. - The writer is closed. - 2 - - - Writes a character to the string asynchronously. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the string asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string to the current string asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the current string. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Represents a reader that can read a sequential series of characters. - 2 - - - Initializes a new instance of the class. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Provides a TextReader with no data to read from. - 1 - - - Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. - An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. - The is closed. - An I/O error occurs. - 1 - - - Reads the next character from the text reader and advances the character position by one character. - The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 2 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the text reader and returns the data as a string. - The next line from the reader, or null if all characters have been read. - An I/O error occurs. - There is insufficient memory to allocate a buffer for the returned string. - The is closed. - The number of characters in the next line is larger than - 1 - - - Reads a line of characters asynchronously and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. - The number of characters in the next line is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the text reader and returns them as one string. - A string that contains all characters from the current position to the end of the text reader. - An I/O error occurs. - The is closed. - There is insufficient memory to allocate a buffer for the returned string. - The number of characters in the next line is larger than - 1 - - - Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. - The number of characters is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Represents a writer that can write a sequential series of characters. This class is abstract. - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format provider. - An object that controls formatting. - - - Stores the newline characters used for this TextWriter. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, returns the character encoding in which the output is written. - The character encoding in which the output is written. - 1 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The text writer is disposed. - The writer is currently in use by a previous write operation. - - - Gets an object that controls formatting. - An object for a specific culture, or the formatting of the current culture if no other culture is specified. - 2 - - - Gets or sets the line terminator string used by the current TextWriter. - The line terminator string for the current TextWriter. - 2 - - - Provides a TextWriter with no backing store that can be written to, but not read from. - 1 - - - Writes the text representation of a Boolean value to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a character array to the text string or stream. - The character array to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters to the text string or stream. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte floating-point value to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object to the text string or stream by calling the ToString method on that object. - The object to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string to the text string or stream. - The string to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - - or is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character array to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If is null, nothing is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a line terminator to the text string or stream. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character followed by a line terminator to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes an array of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The character position in at which to start reading data. - The maximum number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value followed by a line terminator to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. - The object to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string followed by a line terminator to the text string or stream. - The string to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - A string or object is passed in as null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes an array of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If the character array is null, only the line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml deleted file mode 100644 index 07b2661f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/de/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. - 2 - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. - Der Eingabestream. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - oder ist null. - - - Gewährt Zugriff auf den zugrunde liegenden Stream von . - Der BinaryReader zugeordnete, zugrunde liegende Stream. - 2 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. - Die Anzahl der zu lesenden Bytes. - Das Ende des Streams ist erreicht, bevor gelesen werden konnte. - E/A-Fehler. - Die angeforderten überschreiten die interne Puffergröße. - - - Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. - Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. - 2 - - - Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. - Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Bytes. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 32-Bit-Ganzzahl in komprimiertem Format. - Eine 32-Bit-Ganzzahl in komprimiertem Format. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Der Datenstrom ist beschädigt. - - - Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - true, wenn das Byte ungleich 0 (null) ist, andernfalls false. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - Das nächste aus dem aktuellen Stream gelesene Byte. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. - Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - E/A-Fehler. - Der Stream ist geschlossen. - - ist negativ. - 2 - - - Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein aus dem aktuellen Stream gelesenes Zeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Ein Ersatzzeichenzeichen wurde gelesen. - 2 - - - Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Zeichen. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - Der Stream ist geschlossen. - E/A-Fehler. - - ist negativ. - 2 - - - Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. - Ein aus dem aktuellen Stream gelesener Dezimalwert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. - Die gelesene Zeichenfolge. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. - Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. - Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. - 2 - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. - - - Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. - Der Ausgabestream. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Ruft den zugrunde liegenden Stream von ab. - Der BinaryWriter zugeordnete, zugrunde liegende Stream. - 1 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Gibt eine -Klasse ohne Sicherungsspeicher an. - 1 - - - Enthält den zugrunde liegenden Stream. - - - Legt die Position im aktuellen Stream fest. - Die Position im aktuellen Stream. - Ein Byteoffset im Verhältnis zu . - Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. - Der Dateizeiger wurde an eine ungültige Position verschoben. - Der -Wert ist ungültig. - 1 - - - Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. - Der zu schreibende Boolean-Wert (0 (null) oder 1). - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Bytearray in den zugrunde liegenden Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - E/A-Fehler. - Der Stream ist geschlossen. - - ist null. - 1 - - - Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Bytes. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). - E/A-Fehler. - Der Stream ist geschlossen. - - ist ein einzelnes Ersatzzeichen. - 1 - - - Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - - ist null. - Der Stream ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. - Der zu schreibende Dezimalwert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Der zu schreibende 8-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Der zu schreibende 4-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. - Der zu schreibende Wert. - E/A-Fehler. - - ist null. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. - Die zu schreibende 32-Bit-Ganzzahl. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - Der Stream ist geschlossen. - - - Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. - 2 - - - Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. - - - Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - - - Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. - - ist null. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - - Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - - ist null. - - oder ist kleiner als 0. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , bei dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. - Die Anfangsgröße des internen Arrays in Bytes. - - ist negativ. - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 2 - - - Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. - Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. - Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. - Der aktuelle Stream ist geschlossen. - set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. - 2 - - - Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. - Das Token zum überwachen von Abbruchanforderungen . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen . - Der Stream wurde freigegeben. - - - Ruft die Länge des Streams in Bytes ab. - Die Länge des Streams in Bytes. - Der Stream ist geschlossen. - 2 - - - Ruft die aktuelle Position im Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. - Der Stream ist geschlossen. - 2 - - - Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. - Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. - Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - - subtrahiert von der Pufferlänge ist kleiner als . - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem aktuellen Stream. - Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Position im aktuellen Stream auf den angegebenen Wert fest. - Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. - Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. - Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. - Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. - - ist größer als . - Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. - Der Wert, auf den die Länge festgelegt werden soll. - Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. - - ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. - 2 - - - Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. - Ein neues Bytearray. - 2 - - - Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. - true, wenn die Konvertierung erfolgreich war, andernfalls false. - Das Bytearraysegment, aus dem der Stream erstellt wurde. - - - Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. - - subtrahiert von der Pufferlänge ist kleiner als . - - oder ist negativ. - E/A-Fehler. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuelle Position im aktuellen Stream. - Das zu schreibende Byte. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. - Der aktuelle Stream ist geschlossen. - 2 - - - Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. - Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. - - ist null. - Der aktuelle Stream oder der Zielstream ist geschlossen. - 2 - - - Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. - 2 - - - Gibt den Anfang eines Streams an. - - - Gibt die aktuelle Position innerhalb eines Streams an. - - - Gibt das Ende eines Streams an. - - - Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. - 1 - - - Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - 2 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 1 - - - Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt alle vom verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - E/A-Fehler. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - Der Stream wurde freigegeben. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. - Ein Long-Wert, der die Länge des Streams in Bytes darstellt. - Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Ein Stream ohne Sicherungsspeicher. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. - Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. - Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. - Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. - Die Summe aus und ist größer als die Pufferlänge. - - ist null. - - oder ist negativ. - E/A-Fehler. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. - Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. - Die neue Position innerhalb des aktuellen Streams. - Ein Byteoffset relativ zum -Parameter. - Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. - Die gewünschte Länge des aktuellen Streams in Bytes. - E/A-Fehler. - Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. - Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. - Die Summe der  und  ist größer als die Länge des Puffers. - - ist null. - - oder  ist negativ. - E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. - Der Stream unterstützt das Schreiben nicht. - - wurde aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das Byte, das in den Stream geschrieben werden soll. - E/A-Fehler. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. - Der zu lesende Stream. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - Die Mindestgröße des Puffers. - Lesevorgänge werden vom Stream nicht unterstützt. - - oder ist null. - - ist kleiner oder gleich 0 (null). - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. - Die Mindestgröße des Puffers. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - - Gibt den zugrunde liegenden Stream zurück. - Der zugrunde liegende Stream. - 2 - - - Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. - Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. - 2 - - - Löscht den internen Puffer. - 2 - - - Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. - true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. - Der zugrunde liegende Stream wurde verworfen. - 1 - - - Ein -Objekt um einen leeren Stream. - 1 - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. - E/A-Fehler. - 1 - - - Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. - Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Index von , bei dem mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - Ein E/A-Fehler ist aufgetreten. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. - Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. - Die Anzahl der Zeichen ist niedriger als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - - ist schreibgeschützt. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - - oder ist null. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. - true, um zum Entleeren des Puffers zu zwingen, andernfalls false. - 1 - - - Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. - Der Stream, in den dieser StreamWriter schreibt. - 2 - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. - 2 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. - Der aktuelle Writer wird geschlossen. - Ein E/A-Fehler ist aufgetreten. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - 1 - - - Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt ein Zeichen in den Stream. - Das in den Stream zu schreibende Zeichen. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Zeichenarray in den Stream. - Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Teilarray von Zeichen in den Stream. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt eine Zeichenfolge in den Stream. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Implementiert einen , der aus einer Zeichenfolge liest. - 2 - - - Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. - Die Zeichenfolge, mit der der initialisiert werden soll. - Der -Parameter ist null. - - - Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Anfangsindex im Puffer. - Die Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. - Der aktuelle Reader ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - 2 - - - Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. - Die Anzahl der Zeichen ist niedriger als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. - Ein -Objekt zum Steuern der Formatierung. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . - Der StringBuilder, in den geschrieben werden soll. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. - Der StringBuilder, in den geschrieben werden soll. - Ein -Objekt zum Steuern der Formatierung. - - ist null. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die Encoding, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - - - Gibt den zugrunde liegenden zurück. - Der zugrunde liegende StringBuilder. - 2 - - - Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - 2 - - - Schreibt ein Zeichen in die Zeichenfolge. - Das zu schreibende Zeichen. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Teilarray von Zeichen in die Zeichenfolge. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - - oder ist negativ. - ( + )> .Length. - Der Writer ist geschlossen. - 2 - - - Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. - Die zu schreibende Zeichenfolge. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Stellt einen TextReader ohne zu lesende Daten bereit. - 1 - - - Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. - Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 2 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. - E/A-Fehler. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der ist geschlossen. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. - E/A-Fehler. - Der ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. - Die Anzahl der Zeichen ist niedriger als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. - Ein -Objekt zum Steuern der Formatierung. - - - Speichert die für diesen TextWriter verwendeten Zeilenendemarken. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. - Die Zeichencodierung, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Textwriter wird freigegeben. - Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Ruft ein Objekt zum Steuern der Formatierung ab. - Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. - 2 - - - Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. - Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. - 2 - - - Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichenarray. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. - Das zu schreibende Objekt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - - oder ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - Eine Zeichenfolge oder ein Objekt wird als null übergeben. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml deleted file mode 100644 index 0b2c206b..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/es/System.IO.xml +++ /dev/null @@ -1,2090 +0,0 @@ - - - - System.IO - - - - Lee tipos de datos primitivos como valores binarios en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. - La secuencia de entrada. - La secuencia no admite la lectura, es null, o ya está cerrada. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de o es null. - - - Expone el acceso a la secuencia subyacente de . - Secuencia subyacente asociada a BinaryReader. - 2 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. - Número de bytes que se va a leer. - Se llega al final de la secuencia antes de se ha podido leer. - Se produce un error de E/S. - Solicitado es mayor que el tamaño del búfer interno. - - - Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. - Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. - 2 - - - Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. - Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. - Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de bytes que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. - Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de caracteres que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero de 32 bits en formato comprimido. - Entero de 32 bits en formato comprimido. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - La secuencia está dañada. - - - Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Es true si el byte es distinto de cero; en caso contrario, es false. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Siguiente byte que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. - Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. - Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - Se produce un error de E/S. - La secuencia está cerrada. - - es negativo. - 2 - - - Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. - Carácter que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - Se ha leído un carácter suplente. - 2 - - - Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. - Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. - Número de caracteres que se va a leer. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - La secuencia está cerrada. - Se produce un error de E/S. - - es negativo. - 2 - - - Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. - Valor decimal que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. - Valor de punto flotante de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. - Entero con signo de 2 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Entero con signo de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. - Entero con signo de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. - Byte con signo que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Valor de punto flotante de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. - Cadena que se lee. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. - Entero sin signo de 2 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. - Entero sin signo de 4 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. - Entero sin signo de 8 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase que escribe en una secuencia. - - - Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. - Flujo de salida. - La secuencia no admite escritura o ya se encuentra cerrada. - - es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - Flujo de salida. - Codificación de caracteres que se utilizará. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. - Flujo de salida. - Codificación de caracteres que se utilizará. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Obtiene la secuencia subyacente del objeto . - Flujo subyacente asociado a BinaryWriter. - 1 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Especifica un objeto sin memoria auxiliar. - 1 - - - Contiene la secuencia subyacente. - - - Establece la posición en la secuencia actual. - Posición con la secuencia actual. - Desplazamiento de bytes relacionado con . - Un campo de que indica el punto de referencia del que se obtiene la nueva posición. - El puntero de archivo se ha movido a una posición no válida. - El valor de no es válido. - 1 - - - Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. - Valor Boolean que se va a escribir (0 ó 1). - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte sin signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una matriz de bytes en la secuencia subyacente. - Matriz de bytes que contiene los datos que se van a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es null. - 1 - - - Escribe una región de una matriz de bytes en la secuencia actual. - Matriz de bytes que contiene los datos que se van a escribir. - Punto inicial de donde comenzará la escritura. - Número de bytes que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. - El carácter Unicode no suplente que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es un carácter suplente único. - 1 - - - Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - - es null. - La secuencia está cerrada. - Se produce un error de E/S. - 1 - - - Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Punto inicial de donde se empieza a leer. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. - Valor decimal que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Valor de punto flotante de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero con signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero con signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero con signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte con signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Valor de punto flotante de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. - Valor que se va a escribir. - Se produce un error de E/S. - - es null. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero sin signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero sin signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero sin signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero de 32 bits en formato comprimido. - Entero de 32 bits que se va a escribir. - Se llega al final de la secuencia. - La secuencia está cerrada. - La secuencia está cerrada. - - - Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. - 2 - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - - - Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Excepción que se inicia cuando el formato de un flujo de datos no es válido. - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el mensaje de error especificado. - Mensaje de error que explica la razón de la excepción. - - - Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. - Mensaje de error que explica la razón de la excepción. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. - - - Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. - Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - El valor de es null. - - o es menor que cero. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - o son negativos. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. - El valor de es null. - - o es negativo. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. - Tamaño inicial de la matriz interna en bytes. - - es negativo. - - - Obtiene un valor que indica si la secuencia actual admite lectura. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite búsquedas. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 2 - - - Obtiene o establece el número de bytes asignados a esta secuencia. - Longitud de la parte utilizable del búfer para la secuencia. - Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. - La secuencia actual está cerrada. - set se invoca en una secuencia cuya capacidad no se puede modificar. - 2 - - - Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero. - Token para supervisar solicitudes de cancelación. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Reemplaza el método de modo que no se realice ninguna acción. - 2 - - - De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación. - Se ha eliminado la secuencia. - - - Obtiene la longitud de la secuencia en bytes. - Longitud de la secuencia en bytes. - La secuencia está cerrada. - 2 - - - Obtiene o establece la posición actual dentro de la secuencia. - Posición actual dentro de la secuencia. - La posición se establece en un valor negativo o un valor mayor que . - La secuencia está cerrada. - 2 - - - Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. - Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. - Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. - Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - - resta de la longitud del búfer es menor que . - La instancia de la secuencia actual está cerrada. - 2 - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia actual. - El byte convertido en un o -1 si se llega al final de la secuencia. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la posición dentro de la secuencia actual en el valor especificado. - Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. - Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. - Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. - Se ha intentado realizar una búsqueda antes del inicio de la secuencia. - - es mayor que . - Hay un no válido . o bien se produjo un desbordamiento aritmético. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la longitud de la secuencia actual en el valor especificado. - Valor en el que establecer la longitud. - La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. - - es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. - 2 - - - Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . - Nueva matriz de bytes. - 2 - - - Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. - Es true si la conversión se realiza correctamente; en caso contrario, es false. - El segmento de matriz de bytes desde el que se creó esta secuencia. - - - Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número máximo de bytes que se pueden escribir. - El valor de es null. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. - - resta de la longitud del búfer es menor que . - - o son negativos. - Se produce un error de E/S. - La instancia de la secuencia actual está cerrada. - 2 - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte en la posición actual de la secuencia actual. - Byte que se va a escribir. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. - La secuencia actual está cerrada. - 2 - - - Escribe el contenido completo de esta secuencia de memoria en otra secuencia. - Secuencia en la que se va a escribir esta secuencia de memoria. - El valor de es null. - La secuencia actual o de destino está cerrada. - 2 - - - Especifica la posición usada para buscar en una secuencia. - 2 - - - Especifica el comienzo de una secuencia. - - - Especifica lo posición actual dentro de la secuencia. - - - Especifica el final de una secuencia. - - - Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase . - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. - true si la secuencia admite lectura; en caso contrario, false. - 1 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. - true si la secuencia admite búsquedas; en caso contrario, false. - 1 - - - Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - 2 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 1 - - - Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera todos los recursos usados por . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Se produce un error de E/S. - 2 - - - Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - Se ha eliminado la secuencia. - - - Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. - Un valor Long que representa la longitud de la secuencia en bytes. - Una clase derivada de Stream no admite la búsqueda. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Stream sin memoria auxiliar. - 1 - - - Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. - Posición actual dentro de la secuencia. - Se produce un error de E/S. - La secuencia no admite búsquedas. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. - Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. - Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. - Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. - Número máximo de bytes que se deben leer de la secuencia actual. - La suma de y es mayor que la longitud del búfer. - El valor de es null. - - o es negativo. - Se produce un error de E/S. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. - Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. - La nueva posición dentro de la secuencia actual. - Desplazamiento de bytes relacionado con el parámetro . - Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. - Se produce un error de E/S. - La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. - Longitud deseada de la secuencia actual, en bytes. - Se produce un error de E/S. - La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. - Matriz de bytes.Este método copia bytes desde al flujo actual. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número de bytes que se deben escribir en la secuencia actual. - La suma de  y  es mayor que la longitud del búfer. - - es null. - - o  es negativo. - Se produjo un error de E/S, como no se puede encontrar el archivo especificado. - La secuencia no es compatible con la escritura. - - se llama después de cerrar la secuencia. - 1 - - - Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. - Byte que se debe escribir en la secuencia. - Se produce un error de E/S. - La secuencia no admite escritura o ya se encuentra cerrada. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 1 - - - Inicializa una nueva instancia de la clase para el flujo especificado. - Secuencia que se va a leer. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - Tamaño mínimo de búfer. - La secuencia no admite lectura. - El valor de o es null. - - es menor o igual que cero. - - - Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. - Tamaño mínimo de búfer. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - - - Devuelve la secuencia subyacente. - Secuencia subyacente. - 2 - - - Obtiene la codificación de caracteres que actualmente utiliza este objeto . - Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . - 2 - - - Borra el búfer interno. - 2 - - - Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene un valor que indica si la actual posición está al final de la secuencia. - Es true si la actual posición está al final de la secuencia; en caso contrario, es false. - Se ha eliminado la secuencia subyacente. - 1 - - - Objeto en torno a una secuencia vacía. - 1 - - - Devuelve el siguiente carácter disponible pero no lo consume. - Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. - El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. - Se produce un error de E/S. - 1 - - - Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. - Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Índice de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - La longitud del búfer menos es menor que . - El valor de es null. - - o es negativo. - Se produce un error de E/S, como el cierre de la secuencia. - 1 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - - o es negativo. - El se cierra. - Error de E/S. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. - El número de caracteres en la siguiente línea es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la secuencia. - Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. - El número de caracteres es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. - 1 - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - No se puede escribir en . - - is null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - - o es null. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . - Es true para que vacíe su búfer; en caso contrario, es false. - 1 - - - Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. - Secuencia en la que escribe este StreamWriter. - 2 - - - Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. - truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - - - Obtiene el donde se escribe el resultado. - - especificado en el constructor para la instancia actual o si no se ha especificado una codificación. - 2 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. - El sistema de escritura actual está cerrado. - Se produjo un error de E/S. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - 1 - - - Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe un carácter en la secuencia. - Carácter que se va a escribir en la secuencia. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una matriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una submatriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una cadena en la secuencia. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comienza la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Implementa que lee en una cadena. - 2 - - - Inicializa una nueva instancia de la clase que lee en la cadena especificada. - Cadena en la que debe inicializarse. - El parámetro es null. - - - Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Devuelve el siguiente carácter disponible pero no lo consume. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - El sistema de lectura actual está cerrado. - 2 - - - Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. - Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. - El sistema de lectura actual está cerrado. - 2 - - - Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . - Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Índice inicial del búfer. - Número de caracteres que se va a leer. - - es null. - La longitud del búfer menos es menor que . - - o son negativos. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. - El sistema de lectura actual está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - 2 - - - Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Contenido desde la posición actual hasta el final de la cadena subyacente. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. - El número de caracteres es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir información en una cadena.La información se almacena en el subyacente. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Inicializa una nueva instancia de la clase que escribe en el especificado. - Objeto StringBuilder en el que se va a escribir. - - es null. - - - Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. - Objeto StringBuilder en el que se va a escribir. - Objeto que controla las operaciones de formato. - - es null. - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene el donde se escribe el resultado. - Encoding donde se escribe el resultado. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - - - Devuelve el subyacente. - Objeto StringBuilder subyacente. - 2 - - - Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. - Cadena que contiene los caracteres escritos en el StringWriter actual. - 2 - - - Escribe un carácter en la cadena. - Carácter que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe una submatriz de caracteres en la cadena. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - - o son negativos. - ( + ) > .Length. - El sistema de escritura está cerrado. - 2 - - - Escribe una cadena en la cadena actual. - Cadena que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe un carácter en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena actual de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Representa un lector que puede leer una serie secuencial de caracteres. - 2 - - - Inicializa una nueva instancia de la clase . - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. - - - Proporciona un TextReader sin datos del que leer. - 1 - - - Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. - Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. - Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 2 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. - Línea siguiente del lector o null si se han leído todos los caracteres. - Se produce un error de E/S. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El objeto está cerrado. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. - Se produce un error de E/S. - El objeto está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. - El número de caracteres es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Almacena los caracteres de nueva línea usados para el TextWriter. - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. - Codificación de caracteres donde se escriben los resultados. - 1 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se desecha el sistema de escritura de texto. - El sistema de escritura está actualmente en uso por una operación de escritura anterior. - - - Obtiene un objeto que controla las operaciones de formato. - Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. - 2 - - - Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. - Cadena de terminador de línea para el TextWriter actual. - 2 - - - Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. - Objeto que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena en la cadena o secuencia de texto. - Cadena que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - El valor de o es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea en la cadena o secuencia. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - Posición del carácter en donde comenzar a leer datos. - Número máximo de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. - Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. - Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - Una cadena u objeto se pasa como null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml deleted file mode 100644 index 30dc29ab..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/fr/System.IO.xml +++ /dev/null @@ -1,2201 +0,0 @@ - - - - System.IO - - - - Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux d'entrée. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - - Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. - Flux d'entrée. - Encodage des caractères à utiliser. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux d'entrée. - Encodage des caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - ou a la valeur null. - - - Expose l'accès au flux sous-jacent de l'élément . - Flux sous-jacent associé à l'élément BinaryReader. - 2 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. - Nombre d'octets à lire. - La fin du flux est atteinte avant que n'ait pu être lu. - Une erreur d'E/S se produit. - - demandé est plus grand que la taille de la mémoire tampon interne. - - - Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. - Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. - 2 - - - Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. - Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre d'octets à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. - Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier 32 bits au format compressé. - Entier 32 bits au format compressé. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Le flux est endommagé. - - - Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. - true si l'octet est différent de zéro ; sinon, false. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. - Octet suivant lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. - Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. - Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Une erreur d'E/S se produit. - Le flux est fermé. - - est négatif. - 2 - - - Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. - Caractère lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Un caractère de substitution a été lu. - 2 - - - Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. - Nombre de caractères à lire. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Le flux est fermé. - Une erreur d'E/S se produit. - - est négatif. - 2 - - - Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. - Valeur décimale lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Valeur à virgule flottante de 8 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. - Entier signé de 2 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Entier signé de 4 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Entier signé de 8 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. - Octet signé lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Valeur à virgule flottante de 4 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. - Chaîne en cours de lecture. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. - Entier non signé de 2 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. - Entier non signé de 4 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. - Entier non signé de 8 octets lu dans ce flux. - La fin du flux est atteinte. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe qui écrit dans un flux. - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux de sortie. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. - Flux de sortie. - Encodage de caractères à utiliser. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux de sortie. - Encodage de caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Obtient le flux sous-jacent de . - Flux sous-jacent associé à BinaryWriter. - 1 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - 1 - - - Spécifie sans magasin de sauvegarde. - 1 - - - Contient le flux sous-jacent. - - - Définit la position dans le flux actuel. - Position dans le flux actuel. - Offset d'octet par rapport à . - Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. - Le pointeur de fichier a été déplacé vers un emplacement non valide. - La valeur n'est pas valide. - 1 - - - Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. - Valeur Boolean à écrire (0 ou 1). - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. - Octet non signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un tableau d'octets dans le flux sous-jacent. - Tableau d'octets contenant les données à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - a la valeur null. - 1 - - - Écrit une zone d'un tableau d'octets dans le flux actuel. - Tableau d'octets contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre d'octets à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Caractère Unicode de non-substitution à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - est un caractère de substitution unique. - 1 - - - Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Tableau de caractères contenant les données à écrire. - - a la valeur null. - Le flux est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. - Tableau de caractères contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. - Valeur décimale à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Valeur à virgule flottante de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. - Octet signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Valeur à virgule flottante de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. - Valeur à écrire. - Une erreur d'E/S se produit. - - a la valeur null. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier non signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier non signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier non signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un nombre entier 32 bits dans un format compressé. - Entier 32 bits à écrire. - La fin du flux est atteinte. - Le flux est fermé. - Le flux est fermé. - - - Exception levée en cas de tentative de lecture au-delà de la fin du flux. - 2 - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Exception qui est levée lorsque le format d'un flux de données n'est pas valide. - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. - Message d'erreur indiquant la raison de l'exception. - - - Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. - Message d'erreur indiquant la raison de l'exception. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. - Tableau d'octets non signés à partir duquel créer le flux actuel. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - - a la valeur null. - - ou est inférieur à zéro. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. - Taille initiale du tableau interne, en octets. - - est négatif. - - - Obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 2 - - - Obtient ou définit le nombre d'octets alloués pour ce flux. - Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. - La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. - Le flux actuel est fermé. - set est appelé sur un flux dont la capacité ne peut pas être modifiée. - 2 - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. - Jeton pour surveiller les demandes d'annulation. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplace la méthode afin qu'aucune action ne soit effectuée. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation. - Le flux a été supprimé. - - - Obtient la longueur du flux en octets. - Longueur du flux en octets. - Le flux est fermé. - 2 - - - Obtient ou définit la position actuelle dans le flux. - Position actuelle dans le flux. - La position correspond à une valeur négative ou à une valeur supérieure à . - Le flux est fermé. - 2 - - - Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. - Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. - Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - - soustrait à la longueur de la mémoire tampon est inférieur à . - L'instance du flux actuel est fermée. - 2 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet dans le flux actuel. - Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. - L'instance du flux actuel est fermée. - 2 - - - Définit la position dans le flux actuel à la valeur spécifiée. - Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. - Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. - Valeur de type , qui sert de point de référence à la recherche. - Tentative de recherche avant le début du flux. - - est supérieur à . - Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. - L'instance du flux actuel est fermée. - 2 - - - Définit la longueur du flux actuel à la valeur spécifiée. - Valeur à laquelle définir la longueur. - Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. - - est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. - 2 - - - Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . - Nouveau tableau d'octets. - 2 - - - Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. - true si la conversion a réussi ; sinon, false. - Segment de tableau d'octets à partir duquel ce flux a été créé. - - - Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre maximal d'octets à écrire. - - a la valeur null. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. - - soustrait à la longueur de la mémoire tampon est inférieur à . - - ou est négatif. - Une erreur d'E/S se produit. - L'instance du flux actuel est fermée. - 2 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux actuel. - Octet à écrire. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. - Le flux actuel est fermé. - 2 - - - Écrit le contenu complet de ce flux de mémoire dans un autre flux. - Flux dans lequel écrire ce flux de mémoire. - - a la valeur null. - Le flux en cours ou le flux cible est fermé. - 2 - - - Spécifie la position au sein d'un flux à utiliser pour la recherche. - 2 - - - Spécifie le début d'un flux. - - - Spécifie la position actuelle au sein d'un flux. - - - Spécifie la fin d'un flux. - - - Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe . - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux prend en charge la lecture ; sinon, false. - 1 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux prend en charge la recherche ; sinon, false. - 1 - - - Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - 2 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 1 - - - Lit les octets du flux actuel et les écrit dans un autre flux. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Flux vers lequel le contenu du flux actuel sera copié. - Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. - Une erreur d'E/S se produit. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - Le flux a été supprimé. - - - En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. - Valeur de type long représentant la longueur du flux en octets. - Une classe dérivée de Stream ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Élément Stream sans magasin de stockage. - 1 - - - En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. - Position actuelle dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. - Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. - Nombre maximal d'octets à lire dans le flux actuel. - La somme de et de est supérieure à la longueur de la mémoire tampon. - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. - Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. - Nouvelle position dans le flux actuel. - Offset d'octet par rapport au paramètre . - Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. - Longueur souhaitée du flux actuel en octets. - Une erreur d'E/S se produit. - Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. - Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre d'octets à écrire dans le flux actuel. - La somme des  et  est supérieure à la longueur du tampon. - - est null. - - ou  est un nombre négatif. - Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. - Le flux ne prend pas en charge l'écriture. - - a été appelée une fois que le flux a été fermé. - 1 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. - Octet à écrire dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié. - Flux à lire. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. - Flux à lire. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. - Flux à lire. - Encodage des caractères à utiliser. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - Taille minimale de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - - ou a la valeur null. - - est inférieur ou égal à zéro. - - - Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux à lire. - Encodage des caractères à utiliser. - true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. - Taille minimale de la mémoire tampon. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - - Retourne le flux sous-jacent. - Flux sous-jacent. - 2 - - - Obtient l'encodage de caractères actuel utilisé par l'objet actuel. - Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . - 2 - - - Efface la mémoire tampon interne. - 2 - - - Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. - true si la position actuelle dans le flux est à la fin du flux ; sinon, false. - Le flux sous-jacent a été supprimé. - 1 - - - Objet autour d'un flux vide. - 1 - - - Retourne le caractère disponible suivant, mais ne le consomme pas. - Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. - Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. - Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Index de auquel commencer l'écriture. - Nombre maximal de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S, telle que la fermeture du flux, se produit. - 1 - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S s'est produite. - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. - Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du flux. - Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. - Le nombre de caractères est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. - Le flux dans lequel écrire. - - n'est pas accessible en écriture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - - ou est null. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . - true pour forcer à vider sa mémoire tampon ; sinon, false. - 1 - - - Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. - Flux dans lequel ce StreamWriter écrit. - 2 - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - - - Obtient le dans lequel la sortie est écrite. - - spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. - 2 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. - Le writer actuel est fermé. - Une erreur d'E/S s'est produite. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - 1 - - - Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. - 1 - - - Écrit un caractère dans le flux. - Caractère à écrire dans le flux. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un sous-tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit une chaîne dans le flux. - Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire où commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire dans le flux.Si est null, rien n'est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un terminateur de ligne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Implémente qui lit une chaîne. - 2 - - - Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. - Chaîne à laquelle doit être initialisé. - Le paramètre est null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Retourne le prochain caractère disponible, mais ne le consomme pas. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Le lecteur actuel est fermé. - 2 - - - Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. - Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. - Le lecteur actuel est fermé. - 2 - - - Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . - Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Index de début dans la mémoire tampon. - Nombre de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Le lecteur actuel est fermé. - 2 - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. - Le lecteur actuel est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - 2 - - - Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. - Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le lecteur actuel est fermé. - 2 - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. - Le nombre de caractères est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. - Objet qui contrôle la mise en forme. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié. - StringBuilder dans lequel écrire. - - a la valeur null. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. - StringBuilder dans lequel écrire. - Objet qui contrôle la mise en forme. - - a la valeur null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Obtient le dans lequel la sortie est écrite. - Encoding dans lequel la sortie est écrite. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - - - Retourne le sous-jacent. - StringBuilder sous-jacent. - 2 - - - Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. - Chaîne contenant les caractères écrits dans le StringWriter en cours. - 2 - - - Écrit un caractère dans la chaîne. - Caractère à écrire. - Le writer est fermé. - 2 - - - Écrit un sous-tableau de caractères dans la chaîne. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - ou est négatif. - ( + )> .Length. - Le writer est fermé. - 2 - - - Écrit une chaîne dans la chaîne actuelle. - Chaîne à écrire. - Le writer est fermé. - 2 - - - Écrit un caractère dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans la chaîne actuelle de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Représente un lecteur capable de lire une série séquentielle de caractères. - 2 - - - Initialise une nouvelle instance de la classe . - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Fournit un TextReader sans données à lire. - 1 - - - Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. - Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. - Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. - La ligne suivante du lecteur ou null si tous les caractères ont été lus. - Une erreur d'E/S se produit. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - - est fermé. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. - Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. - Une erreur d'E/S se produit. - - est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. - Le nombre de caractères est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. - Objet qui contrôle la mise en forme. - - - Stocke les caractères de saut de ligne utilisés pour ce TextWriter. - - - Libère toutes les ressources utilisées par l'objet . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. - Encodage de caractères dans lequel la sortie est écrite. - 1 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le writer de texte est supprimé. - Le writer est actuellement utilisé par une opération d'écriture précédente. - - - Obtient un objet qui contrôle la mise en forme. - Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. - 2 - - - Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. - Chaîne de marque de fin de ligne pour le TextWriter actuel. - 2 - - - Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. - Objet à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne dans la chaîne ou le flux de texte. - Chaîne à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - - ou a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - Dans , position de caractère à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - Une chaîne ou un objet est passé en tant que null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml deleted file mode 100644 index 46070bec..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/it/System.IO.xml +++ /dev/null @@ -1,2123 +0,0 @@ - - - - System.IO - - - - Legge i tipi di dati primitivi come valori binari in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. - Flusso di input. - Il flusso non supporta la lettura, è null o è già chiuso. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. - Flusso di input. - Codifica dei caratteri da usare. - Il flusso non supporta la lettura, è null o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. - Flusso di input. - Codifica dei caratteri da usare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la lettura, è null o è già chiuso. - - o è null. - - - Espone l'accesso al flusso sottostante dell'oggetto . - Flusso sottostante associato all'oggetto BinaryReader. - 2 - - - Rilascia tutte le risorse usate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Inserisce nel buffer interno il numero specificato di byte letti dal flusso. - Numero di byte da leggere. - È stata raggiunta la fine del flusso prima che fosse possibile leggere . - Si è verificato un errore di I/O. - I richiesti sono superiori alla dimensione del buffer interno. - - - Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. - Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. - 2 - - - Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. - Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. - Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di byte da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. - Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di caratteri da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero a 32 bit in formato compresso. - Intero a 32 bit in formato compresso. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - Flusso danneggiato. - - - Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - true se il byte è diverso da zero; in caso contrario, false. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - Byte successivo letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. - Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. - Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è negativo. - 2 - - - Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Carattere letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - È stato letto un carattere surrogato. - 2 - - - Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. - Numero di caratteri da leggere. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Il flusso è chiuso. - Si è verificato un errore di I/O. - - è negativo. - 2 - - - Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. - Valore decimale letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. - Valore a virgola mobile a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. - Intero con segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Intero con segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. - Intero con segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. - Byte con segno letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Valore a virgola mobile a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. - Stringa da leggere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. - Intero senza segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero senza segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero senza segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe che scrive in un flusso. - - - Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. - Flusso di output. - Il flusso non supporta la scrittura o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. - Flusso di output. - Codifica dei caratteri da utilizzare. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. - Flusso di output. - Codifica dei caratteri da utilizzare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Ottiene il flusso sottostante dell'oggetto . - Flusso sottostante associato a BinaryWriter. - 1 - - - Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Specifica un oggetto privo di archivio di backup. - 1 - - - Contiene il flusso principale. - - - Imposta la posizione all'interno del flusso corrente. - Posizione all'interno del flusso corrente. - Offset dei byte relativo a . - Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. - Il puntatore a file è stato spostato in un percorso non valido. - Il valore di non è valido. - 1 - - - Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. - Valore Boolean da scrivere (0 o 1). - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una matrice di byte nel flusso sottostante. - Matrice di caratteri che contiene i dati da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è null. - 1 - - - Scrive un'area di una matrice di byte nel flusso corrente. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale nel parametro da cui iniziare la scrittura. - Numero di byte da scrivere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Carattere Unicode non surrogato da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è un carattere surrogato singolo. - 1 - - - Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - - è null. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 1 - - - Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale in dal quale avviare la scrittura. - Numero di caratteri da inserire. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. - Valore decimale da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Valore a virgola mobile a otto byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Valore a virgola mobile a quattro byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. - Valore da scrivere. - Si è verificato un errore di I/O. - - è null. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Inserisce un valore intero a 32 bit in un formato compresso. - Intero da 32 bit da scrivere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Il flusso è chiuso. - - - Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. - 2 - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - - - Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Eccezione generata se un flusso di dati è in un formato non valido. - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con un messaggio di errore specificato. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - - - Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. - Matrice di byte senza segno da cui creare il flusso corrente. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - - è null. - - o è minore di zero. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - o è un valore negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. - - è null. - Il valore di o è negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. - Dimensione iniziale in byte della matrice interna. - - è negativo. - - - Ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 2 - - - Ottiene o imposta il numero di byte allocati per questo flusso. - Lunghezza della parte usabile del buffer per il flusso. - È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. - Il flusso corrente è chiuso. - set è stato richiamato su un flusso del quale non è possibile modificare la capacità. - 2 - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. - Token da monitorare per le richieste di annullamento. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. - 2 - - - Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento. - Il flusso è stato eliminato. - - - Ottiene la lunghezza in byte del flusso. - Lunghezza del flusso in byte. - Il flusso è chiuso. - 2 - - - Ottiene o imposta la posizione corrente all'interno del flusso. - Posizione corrente all'interno del flusso. - La posizione è impostata su un valore negativo o maggiore di . - Il flusso è chiuso. - 2 - - - Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. - Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. - Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. - Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - - sottratto alla lunghezza del buffer è minore di . - L'istanza del flusso corrente è chiusa. - 2 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso corrente. - Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la posizione all'interno del flusso corrente sul valore specificato. - Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. - Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. - Valore di tipo , che funge da punto di riferimento per la ricerca. - La ricerca viene tentata prima dell'inizio del flusso. - - è maggiore di . - Il valore di non è valido. -oppure- causato da un overflow aritmetico. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la lunghezza del flusso corrente sul valore specificato. - Valore su cui impostare la lunghezza. - Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. - - è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. - 2 - - - Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . - Nuova matrice di byte. - 2 - - - Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. - true se la conversione riesce; in caso contrario, false. - Segmento di matrice di byte da cui è stato creato questo flusso. - - - Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero massimo di byte da scrivere. - - è null. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. - - sottratto alla lunghezza del buffer è minore di . - - o è un valore negativo. - Si è verificato un errore di I/O. - L'istanza del flusso corrente è chiusa. - 2 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente all'interno del flusso corrente. - Byte da scrivere. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. - Il flusso corrente è chiuso. - 2 - - - Scrive l'intero contenuto del flusso di memoria in un altro flusso. - Flusso in cui scrivere il flusso di memoria. - - è null. - Il flusso corrente o di destinazione è chiuso. - 2 - - - Specifica la posizione in un flusso da utilizzare per le ricerche. - 2 - - - Specifica l'inizio di un flusso. - - - Specifica la posizione corrente all'interno di un flusso. - - - Specifica la fine di un flusso. - - - Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe . - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso supporta la lettura; in caso contrario, false. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso supporta la ricerca; in caso contrario, false. - 1 - - - Ottiene un valore che determina se il flusso corrente prevede il timeout. - Valore che determina se il flusso corrente prevede il timeout. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 1 - - - Legge i byte dal flusso corrente e li scrive in un altro flusso. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Si è verificato un errore di I/O. - 2 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - Il flusso è stato eliminato. - - - Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. - Valore long che rappresenta la lunghezza del flusso in byte. - Una classe derivata da Stream non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Oggetto Stream privo di archivio di backup. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. - Posizione corrente all'interno del flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. - Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. - Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. - Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. - Numero massimo di byte da leggere dal flusso corrente. - La somma di e è maggiore della lunghezza del buffer. - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. - Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. - Nuova posizione all'interno del flusso corrente. - Offset dei byte rispetto al parametro . - Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. - Lunghezza desiderata del flusso corrente in byte. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. - Matrice di byte.Questo metodo copia i byte da nel flusso corrente. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero di byte da scrivere nel flusso corrente. - La somma di  e  è maggiore della lunghezza del buffer. - - è null. - - o  è negativo. - Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. - Il flusso non supporta la scrittura. - - è stato chiamato dopo la chiusura del flusso. - 1 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. - Byte da scrivere nel flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura o è già chiuso. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato. - Flusso da leggere. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. - Flusso da leggere. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. - Flusso da leggere. - Codifica dei caratteri da usare. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - Dimensione minima del buffer. - Il flusso non supporta la lettura. - - o è null. - - è minore o uguale a zero. - - - Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. - Flusso da leggere. - Codifica dei caratteri da usare. - true per cercare i byte order mark all'inizio del file; in caso contrario, false. - Dimensione minima del buffer. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - - Restituisce il flusso sottostante. - Flusso sottostante. - 2 - - - Ottiene la codifica caratteri corrente usata dall'oggetto corrente. - Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . - 2 - - - Cancella il buffer interno. - 2 - - - Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. - true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. - Il flusso sottostante è stato eliminato. - 1 - - - Oggetto che include un flusso vuoto. - 1 - - - Restituisce il carattere successivo disponibile senza usarlo. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. - Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Indice di da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O, come la chiusura del flusso. - 1 - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. - Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. - Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. - Il numero di caratteri è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. - Flusso in cui scrivere. - - non è modificabile. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - - o è null. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - - o è null. - - è negativo. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - o è null. - - è negativo. - - non è modificabile. - - - Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . - true per forzare lo scaricamento del buffer; in caso contrario, false. - 1 - - - Ottiene il flusso sottostante che si interfaccia con un archivio di backup. - Flusso in cui StreamWriter scrive. - 2 - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - - - Ottiene l'oggetto in cui viene scritto l'output. - Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. - 2 - - - Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. - Il writer corrente è chiuso. - Si è verificato un errore di I/O. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive un carattere nel flusso. - Carattere da scrivere nel flusso. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una matrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una sottomatrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una stringa nel flusso. - Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Implementa un oggetto che legge da una stringa. - 2 - - - Inizializza una nuova istanza della classe che legge dalla stringa specificata. - Stringa sulla quale inizializzare . - Il parametro è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Restituisce il carattere successivo disponibile senza utilizzarlo. - Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Il lettore corrente è chiuso. - 2 - - - Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. - Il lettore corrente è chiuso. - 2 - - - Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . - Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Indice iniziale nel buffer. - Numero di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. - Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. - Il lettore corrente è chiuso. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - 2 - - - Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Contenuto dalla posizione corrente alla fine della stringa sottostante. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. - Il numero di caratteri è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il controllo di formato specificato. - Oggetto che controlla la formattazione. - - - Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. - Oggetto StringBuilder in cui scrivere. - - è null. - - - Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. - Oggetto StringBuilder in cui scrivere. - Oggetto che controlla la formattazione. - - è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Recupera l'oggetto in cui viene scritto l'output. - Encoding in cui viene scritto l'output. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di svuotamento asincrona. - - - Restituisce l'oggetto sottostante. - StringBuilder sottostante. - 2 - - - Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. - Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. - 2 - - - Scrive un carattere nella stringa. - Carattere da inserire. - Il writer è chiuso. - 2 - - - Scrive una sottomatrice di caratteri nella stringa. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - Il valore di o è negativo. - ( + )> .Length. - Il writer è chiuso. - 2 - - - Scrive una stringa nella stringa corrente. - Stringa da scrivere. - Il writer è chiuso. - 2 - - - Scrive un carattere nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nella stringa corrente in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. - 2 - - - Inizializza una nuova istanza della classe . - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. - 1 - - - Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. - Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 2 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. - Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. - Si è verificato un errore di I/O. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - La classe è chiusa. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. - Si è verificato un errore di I/O. - La classe è chiusa. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. - Il numero di caratteri è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il provider di formato specificato. - Oggetto che controlla la formattazione. - - - Archivia i caratteri di nuova riga usati per questo TextWriter. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. - Codifica caratteri in cui viene scritto l'output. - 1 - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il writer di testo viene eliminato. - Il writer è attualmente utilizzato da un'operazione di scrittura precedente. - - - Ottiene un oggetto che controlla la formattazione. - Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. - 2 - - - Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. - Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. - 2 - - - Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nella stringa o flusso di testo. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri nella stringa o flusso di testo. - Matrice di caratteri da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. - Oggetto da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa nella stringa o nel flusso di testo. - Stringa da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - - o è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso o nella stringa di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - Posizione del carattere in dalla quale avviare la lettura dei dati. - Numero massimo di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - Viene passato un oggetto o una stringa come null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml deleted file mode 100644 index 4114d626..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/ja/System.IO.xml +++ /dev/null @@ -1,2264 +0,0 @@ - - - - System.IO - - - - プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 - 2 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - 使用する文字エンコーディング。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - は null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 入力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - または が null です。 - - - - の基になるストリームへのアクセスを公開します。 - BinaryReader に関連付けられた、基になるストリーム。 - 2 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 - 読み取るバイト数。 - - 分のバイトを読み取る前にストリームの末尾に到達しました。 - I/O エラーが発生しました。 - 要求された が、内部バッファー サイズより大きくなっています。 - - - 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 - 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 - 2 - - - 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 - - に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取るバイト数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 - バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取る文字の数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 32 ビット整数を圧縮形式で読み取ります。 - 圧縮形式の 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - ストリームが破損しています。 - - - 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った次のバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 - 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - が負の値です。 - 2 - - - 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 現在のストリームから読み取った文字。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - サロゲート文字が読み取られました。 - 2 - - - 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 - 読み取る文字の数。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - - が負の値です。 - 2 - - - 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 - 現在のストリームから読み取った 10 進数値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った符号付きバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 - 読み取った文字列。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号なし整数。 - ストリームの末尾に到達しました。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 - 2 - - - ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - は null なので、 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - 使用する文字エンコーディング。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 出力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - - の基になるストリームを取得します。 - BinaryWriter に関連付けられた、基になるストリーム。 - 1 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - バッキング ストアを持たない を指定します。 - 1 - - - 基になるストリームを保持します。 - - - 現在のストリーム内の位置を設定します。 - 現在のストリームの位置。 - - からのバイト オフセット。 - 新しい位置を取得するための参照ポイントを示す フィールド。 - ファイル ポインターが無効な位置に移動しました。 - - 値が無効です。 - 1 - - - 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 - 書き込む Boolean 値 (0 または 1)。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号なしバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 基になるストリームにバイト配列を書き込みます。 - 書き込むデータが格納されているバイト配列。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は null なので、 - 1 - - - 現在のストリームにバイト配列の特定の領域を書き込みます。 - 書き込むデータが格納されているバイト配列。 - - 内の書き込み開始点。 - 書き込むバイト数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む非サロゲート Unicode 文字。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は、単一のサロゲート文字です。 - 1 - - - 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - は null なので、 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - 内の書き込み開始点。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 - 書き込む 10 進値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号付きバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む値。 - I/O エラーが発生しました。 - - は null なので、 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 32 ビット整数を圧縮形式で書き込みます。 - 書き込む 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - ストリームが閉じられました。 - - - ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 - 2 - - - メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 - - - メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - - - 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - データ ストリームが無効な形式である場合にスローされる例外。 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - - - この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 - - - 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - 現在のストリームを作成する符号なしバイトの配列。 - - は null です。 - - - - プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - - バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - - は null です。 - - または が 0 未満です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 - バイト単位の内部配列の初期サイズ。 - - が負の値です。 - - - 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 2 - - - ストリームに割り当てられたバイト数を取得または設定します。 - ストリームに対してバッファーが使用できる部分の長さ。 - 容量が負の値または現在のストリーム長より小さい値に設定されています。 - 現在のストリームが閉じています。 - 容量を変更できないストリームに対して set が呼び出されました。 - 2 - - - 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 - キャンセル要求を監視するためのトークン。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - アクションが実行されないように、 メソッドをオーバーライドします。 - 2 - - - このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。 - ストリームは破棄されています。 - - - バイト単位のストリーム長を取得します。 - バイト単位のストリーム長。 - ストリームが閉じられました。 - 2 - - - ストリームの現在位置を取得または設定します。 - ストリーム内の現在位置。 - 位置が負の値または より大きい値に設定されています。 - ストリームが閉じられました。 - 2 - - - 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 - バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 - このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 - 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームからバイトを読み取ります。 - - にキャストしたバイト。ストリームの末尾に達した場合は -1。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム内の位置を指定した値に設定します。 - 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 - ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 - シーク参照ポイントとして機能する 型の値。 - ストリームの先頭より前をシークしようとしました。 - - が より大きくなっています。 - 無効な があります。または によって算術オーバーフローが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム長を指定した値に設定します。 - 長さを設定する値。 - 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 - - が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 - 2 - - - - プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 - 新しいバイト配列。 - 2 - - - このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 - 変換が成功した場合は true。それ以外の場合は false。 - このストリームの作成元のバイト配列セグメント。 - - - バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 - データの書き込み元となるバッファー。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリーム内の現在位置に 1 バイトを書き込みます。 - 書き込むバイト。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 - 現在のストリームが閉じています。 - 2 - - - メモリ ストリームの内容全体を別のストリームに書き込みます。 - このメモリ ストリームが書き込まれるストリーム。 - - は null です。 - 現在のストリームまたは対象のストリームは閉じています。 - 2 - - - シークに使用するストリームの場所を指定します。 - 2 - - - ストリームの先頭を指定します。 - - - ストリーム内の現在位置を指定します。 - - - ストリームの末尾を指定します。 - - - バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 - ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 - ストリームがシークをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 - 現在のストリームがタイムアウトできるかどうかを決定する値。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - によって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - I/O エラーが発生しました。 - 2 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。既定値は です。 - ストリームは破棄されています。 - - - 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 - ストリーム長 (バイト単位) を表す long 値。 - Stream から派生したクラスがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - バッキング ストアを持たない Stream。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 - ストリーム内の現在位置。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 - バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 - バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 - 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームから読み取る最大バイト数。 - - と の合計値が、バッファー長より大きい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 - Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 - 現在のストリーム内の新しい位置。 - - パラメーターからの相対バイト オフセット。 - 新しい位置を取得するために使用する参照ポイントを示す 型の値。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 - 現在のストリームの希望の長さ (バイト数)。 - I/O エラーが発生しました。 - ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 - バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームに書き込むバイト数。 - 合計  と  がバッファーの長さより大きい。 - - nullです。 - - または  が負の値です。 - 指定したファイルが見つからないなど、I/O エラーが発生しました。 - ストリームは書き込みをサポートしません。 - - ストリームが閉じられた後が呼び出されました。 - 1 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - ストリームに書き込むバイト。 - I/O エラーが発生しました。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 1 - - - 指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - - が読み取りをサポートしていません。 - - は null です。 - - - バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - は null です。 - - - 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - 最小バッファー サイズ。 - ストリームは読み取りをサポートしません。 - - または が null です。 - - が 0 以下です。 - - - 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 読み取るストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 - 最小バッファー サイズ。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - - - 基になるストリームを返します。 - 基になるストリーム。 - 2 - - - 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 - 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 - 2 - - - 内部バッファーをクリアします。 - 2 - - - 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 - 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 - 基になるストリームは破棄されています。 - 1 - - - 空のストリームの オブジェクト。 - 1 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 - 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 - 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みの開始位置を示す のインデックス。 - 読み取り対象の最大文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。たとえば、ストリームがクローズされています。 - 1 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 - 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - すべての文字の現在位置から末尾までを読み込みます。 - ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 - 1 - - - UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - - が書き込み可能ではありません。 - - は null です。 - - - 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - - または が null です。 - - が書き込み可能ではありません。 - - - 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - true to leave the stream open after the object is disposed; otherwise, false. - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - - が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 - - に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 - 1 - - - バッキング ストアと連結する、基になるストリームを取得します。 - この StreamWriter が書き込むストリーム。 - 2 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - - - 出力の書き込みに使用する を取得します。 - 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 - 2 - - - 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 - 現在のライターがクローズされています。 - I/O エラーが発生しました。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - 1 - - - このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 - 1 - - - ストリームに文字を書き込みます。 - ストリームに書き込む文字。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列を書き込みます。 - 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列の一部を書き込みます。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字列を書き込みます。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - I/O エラーが発生しました。 - 1 - - - 文字を非同期でストリームに書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列から読み取る を実装します。 - 2 - - - 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 - - を初期化する目的の文字列。 - - パラメーターが null です。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 - 基になる文字列の次の文字。または使用できる文字がない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 - バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - バッファー内の開始インデックス。 - 読み取る文字の数。 - - は null なので、 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - 現在のリーダーが閉じています。 - 2 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 - 現在の文字列の次の行。文字列の末尾に到達した場合は null。 - 現在のリーダーが閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 2 - - - 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 - 基になる文字列の現在位置から末尾までの内容。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 現在のリーダーが閉じています。 - 2 - - - 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - - は null なので、 - - - 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - 書式を制御する オブジェクト。 - - は null なので、 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 出力の書き込みに使用する を取得します。 - 出力の書き込み時に適用する Encoding。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - - - 基になる を返します。 - 基になる StringBuilder。 - 2 - - - 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 - 現在の StringWriter に書き込まれた文字を格納している文字列。 - 2 - - - 文字列に文字を書き込みます。 - 書き込む文字。 - ライターが閉じられました。 - 2 - - - 文字配列の一部を文字列に書き込みます。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - または が負の値です。 - ( + )> 。Length. - ライターが閉じられました。 - 2 - - - 現在の文字列に文字列を書き込みます。 - 書き込む文字列。 - ライターが閉じられました。 - 2 - - - 文字列に文字を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に文字列を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 一連の文字を読み取ることができるリーダーを表します。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り対象のデータを TextReader に提供しません。 - 1 - - - リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 - テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 2 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 - リーダーの次の行。またはすべての文字が読み取られた場合は null。 - I/O エラーが発生しました。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - - が閉じています。 - 次の行の文字数が、 を超えています。 - 1 - - - 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 - テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 - I/O エラーが発生しました。 - - が閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 次の行の文字数が、 を超えています。 - 1 - - - テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - この TextWriter で使用する改行文字を格納します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 - 出力の書き込み時に適用する文字エンコーディング。 - 1 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - テキスト ライターは破棄されます。 - ライターは現在、前の書き込み操作で使用中です。 - - - 書式を制御するオブジェクトを取得します。 - 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 - 2 - - - 現在の TextWriter で使用される行終端文字列を取得または設定します。 - 現在の TextWriter で使用する行終端文字列。 - 2 - - - バッキング ストアを持たない書き込み専用の TextWriter を提供します。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字配列をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込みます。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込むオブジェクト。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込みます。 - 書き込む文字列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - - または が null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をテキスト文字列またはストリームに書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - データの読み込みを開始する、 内の文字の位置。 - 書き込む文字の最大数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - 文字列またはオブジェクトが null として渡されました。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml deleted file mode 100644 index 145ab498..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/ko/System.IO.xml +++ /dev/null @@ -1,2262 +0,0 @@ - - - - System.IO - - - - 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. - 2 - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 가 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 또는 가 null인 경우 - - - - 의 내부 스트림에 대한 액세스를 노출합니다. - BinaryReader와 관련된 내부 스트림입니다. - 2 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. - 읽을 바이트 수입니다. - - 를 읽기 전에 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 요청된 가 내부 버퍼 크기보다 큰 경우 - - - 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. - 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. - 2 - - - 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. - - 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 압축 형식의 32비트 정수를 읽습니다. - 압축 형식의 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 스트림이 손상되었습니다. - - - 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 바이트가 0이 아니면 true이고 0이면 false입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 다음 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. - 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 현재 스트림에서 읽은 문자입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 서로게이트 문자를 읽은 경우 - 2 - - - 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. - 읽을 문자 수입니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 10진 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. - 읽어 오는 문자열입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. - 2 - - - 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 가 null입니다. - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - - 의 내부 스트림을 가져옵니다. - BinaryWriter와 관련된 내부 스트림입니다. - 1 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 1 - - - 백업 저장소가 없는 를 지정합니다. - 1 - - - 내부 스트림을 보유합니다. - - - 현재 스트림 내에서 위치를 설정합니다. - 현재 스트림에서의 위치입니다. - - 에 상대적인 바이트 오프셋입니다. - 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. - 파일 포인터가 잘못된 위치로 이동한 경우 - - 값이 잘못된 경우 - 1 - - - false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. - 쓸 Boolean 값(0 또는 1)입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 없는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 내부 스트림에 바이트 배열을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 null입니다. - 1 - - - 현재 스트림에 바이트 배열 영역을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 단일 서로게이트 문자인 경우 - 1 - - - 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - - 가 null입니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. - 출력할 10진수 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 있는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - - 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 값입니다. - I/O 오류가 발생하는 경우 - - 가 null입니다. - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 압축 형식의 32비트 정수를 씁니다. - 쓸 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - 스트림이 닫혀 있는 경우 - - - 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. - 2 - - - 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - - 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - - - 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - - - 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 현재 스트림을 만들 부호 없는 바이트의 배열입니다. - - 가 null인 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - - 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - - 가 null인 경우 - - 또는 가 0보다 작은 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 내부 배열의 초기 크기(바이트)입니다. - - 가 음수인 경우 - - - 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 2 - - - 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. - 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. - 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 - 현재 스트림이 닫혀 있는 경우 - 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 - 2 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. - 취소 요청을 모니터링할 토큰입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - - 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다. - 스트림이 삭제된 경우 - - - 스트림의 길이(바이트)를 가져옵니다. - 스트림의 길이(바이트)입니다. - 스트림이 닫혀 있는 경우 - 2 - - - 스트림 내의 현재 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - 위치가 음수 값이나 보다 큰 값으로 설정된 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. - 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. - 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트를 읽습니다. - - 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림 내의 위치를 지정된 값으로 설정합니다. - 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. - 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. - 검색 참조 지점 역할을 하는 형식의 값입니다. - 스트림의 시작 전에 검색하려고 한 경우 - - 가 보다 큰 경우 - 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림의 길이를 지정된 값으로 설정합니다. - 길이를 설정할 값입니다. - 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 - - 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. - 2 - - - - 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. - 새 바이트 배열입니다. - 2 - - - 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. - 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. - 이 스트림을 만든 바이트 배열 세그먼트입니다. - - - 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. - 데이터를 쓸 버퍼입니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 위치에서 현재 스트림에 바이트를 씁니다. - 쓸 바이트입니다. - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 - 현재 스트림이 닫혀 있는 경우 - 2 - - - 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. - 이 메모리 스트림을 쓸 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 닫혀 있는 경우 - 2 - - - 탐색에 사용할 스트림 내 위치를 지정합니다. - 2 - - - 스트림의 맨 앞을 지정합니다. - - - 스트림 내의 현재 위치를 지정합니다. - - - 스트림의 맨 끝을 지정합니다. - - - 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. - 2 - - - 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 에서 사용하는 모든 리소스를 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. - I/O 오류가 발생하는 경우 - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - 스트림이 삭제된 경우 - - - 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. - 스트림 길이(바이트)를 나타내는 long 값입니다. - Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 백업 저장소가 없는 Stream입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - I/O 오류가 발생하는 경우 - 스트림이 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. - 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. - 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에서 읽을 최대 바이트 수입니다. - - 와 의 합계가 버퍼 길이보다 큰 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. - Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. - 현재 스트림 내의 새 위치입니다. - - 매개 변수에 상대적인 바이트 오프셋입니다. - 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. - 원하는 현재 스트림의 길이(바이트)입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. - 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에 쓸 바이트 수입니다. - 총  및  버퍼 길이 보다 큽니다. - - null입니다. - - 또는  음수입니다. - 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. - 스트림이 쓰기를 지원하지 않습니다. - - 스트림이 닫힌 후 호출 되었습니다. - 1 - - - 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. - 스트림에 쓸 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 1 - - - 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - 최소 버퍼 크기입니다. - 스트림이 읽기를 지원하지 않습니다. - - 또는 가 null인 경우 - - 가 0보다 작거나 같은 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. - 최소 버퍼 크기입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - - - 내부 스트림을 반환합니다. - 내부 스트림입니다. - 2 - - - 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. - 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. - 2 - - - 내부 버퍼를 지웁니다. - 2 - - - 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. - 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. - 내부 스트림이 삭제된 경우 - 1 - - - 빈 스트림 주위의 개체입니다. - 1 - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - - 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. - 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 인덱스입니다. - 읽을 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫히는 등의 I/O 오류가 발생한 경우 - 1 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. - 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - - 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. - 1 - - - UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - - 에 쓸 수 없는 경우 - - 가 null인 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - - 또는 가 null인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - true to leave the stream open after the object is disposed; otherwise, false. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - - 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. - - 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. - 1 - - - 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. - 이 StreamWriter가 쓰고 있는 스트림입니다. - 2 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - - - 출력이 쓰여질 을 가져옵니다. - 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. - 2 - - - 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. - 현재 writer가 닫힌 경우 - I/O 오류가 발생한 경우 - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - 1 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. - 1 - - - 스트림에 문자를 씁니다. - 스트림에 쓸 문자입니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자의 하위 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자열을 씁니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작할 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 줄 종결자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열에서 읽어오는 를 구현합니다. - 2 - - - 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. - - 가 초기화되어야 하는 문자열입니다. - - 매개 변수가 null인 경우 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 버퍼의 시작 인덱스입니다. - 읽을 문자 수입니다. - - 가 null입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. - 현재 판독기가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 2 - - - 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. - 내부 문자열의 현재 위치에서 끝까지의 내용입니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 형식 지정을 제어하는 개체입니다. - - - 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - - 가 null입니다. - - - 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - 형식 지정을 제어하는 개체입니다. - - 가 null입니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 출력이 쓰여질 을 가져옵니다. - 출력이 쓰여질 Encoding입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 비동기 플러시 작업을 나타내는 작업입니다. - - - 내부 를 반환합니다. - 내부 StringBuilder입니다. - 2 - - - 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. - 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. - 2 - - - 문자를 문자열에 씁니다. - 쓸 문자입니다. - 작성기가 닫힌 경우 - 2 - - - 문자의 하위 배열을 문자열에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 또는 가 음수인 경우 - ( + )> 인 경우Length. - 작성기가 닫힌 경우 - 2 - - - 문자를 현재 문자열에 씁니다. - 쓸 문자열입니다. - 작성기가 닫힌 경우 - 2 - - - 문자를 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자를 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - TextReader에 읽을 데이터를 제공하지 않습니다. - 1 - - - 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. - I/O 오류가 발생하는 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - - 가 닫힌 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. - I/O 오류가 발생하는 경우 - - 가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 서식 지정을 제어하는 개체입니다. - - - 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. - 출력을 쓰는 문자 인코딩입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. - - - 서식 지정을 제어하는 개체를 가져옵니다. - 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. - 2 - - - 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. - 현재 TextWriter의 줄 종결자 문자열입니다. - 2 - - - 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. - 1 - - - Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - - 또는 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - 데이터 읽기를 시작하는 의 문자 위치입니다. - 쓸 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - 문자열이나 개체가 null로 전달되는 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml deleted file mode 100644 index d9ad6103..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/ru/System.IO.xml +++ /dev/null @@ -1,2023 +0,0 @@ - - - - System.IO - - - - Считывает примитивные типы данных как двоичные значения в заданной кодировке. - 2 - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Входной поток. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. - Входной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Входной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Параметр или имеет значение null. - - - Предоставляет доступ к базовому потоку объекта . - Базовый поток, связанный с объектом BinaryReader. - 2 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. - Количество байтов, чтение которых необходимо выполнить. - Конец потока достигнут раньше, чем было выполнено чтение байтов. - Ошибка ввода-вывода. - Запрошенное значение превышает размер внутреннего буфера. - - - Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. - Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. - Ошибка ввода-вывода. - Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. - 2 - - - Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. - Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Количество байтов, чтение которых необходимо выполнить. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. - Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Число символов для чтения. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число в сжатом формате. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Поток поврежден. - - - Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. - Значение true, если байт не равен нулю; в противном случае — значение false. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. - Следующий байт, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. - Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. - Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Ошибка ввода-вывода. - Поток закрыт. - Значение отрицательно. - 2 - - - Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Символ, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Выполнено чтение символа-заместителя. - 2 - - - Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. - Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. - Количество символов, которое необходимо считать. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Поток закрыт. - Ошибка ввода-вывода. - Значение отрицательно. - 2 - - - Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. - Десятичное значение, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Число с плавающей запятой длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Целое число со знаком длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. - Байт со знаком, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Число с плавающей запятой длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. - Считываемая строка. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число без знака длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число без знака длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. - Целое число без знака длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. - 2 - - - Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Выходной поток. - Поток не поддерживает запись или был закрыт до начала операции. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. - Выходной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Выходной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Получает базовый поток . - Базовый поток, связанный с объектом BinaryWriter. - 1 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Задает без резервного хранилища. - 1 - - - Содержит базовый поток. - - - Задает позицию в текущем потоке. - Позиция в текущем потоке. - Смещение в байтах относительно . - Поле указывает точку отсчета, относительно которой указывается новая позиция. - Указатель позиции в файле перемещен в недопустимую позицию. - Значение является недопустимым. - 1 - - - Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. - Записываемое в поток значение типа Boolean (0 или 1). - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. - Записываемый в поток байт без знака. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись массива байтов в базовый поток. - Массив байтов, содержащий записываемые в поток данные. - Ошибка ввода-вывода. - Поток закрыт. - Параметр имеет значение null. - 1 - - - Выполняет запись части массива байтов в текущий поток. - Массив байтов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество записываемых байтов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. - Незаменяющий символ Юникода, который необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - - представляет собой единичный символ-заместитель. - 1 - - - Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. - Массив символов, содержащий записываемые в поток данные. - Параметр имеет значение null. - Поток закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. - Массив символов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. - Десятичное значение, которое необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число со знаком размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число со знаком размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число со знаком размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. - Байт со знаком, который необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. - Записываемое значение. - Ошибка ввода-вывода. - Параметр имеет значение null. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число без знака размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число без знака размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число без знака размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число, которое необходимо записать. - Достигнут конец потока. - Поток закрыт. - Поток закрыт. - - - Исключение, которое создается при попытке выполнить чтение за пределами потока. - 2 - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - - - Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Исключение возникает, когда поток данных имеет недопустимый формат. - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным сообщением об ошибке. - Сообщение об ошибке с объяснением причин исключения. - - - Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. - Сообщение об ошибке с объяснением причин исключения. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. - Массив байтов без знака, из которого создается текущий поток. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Свойство имеет значение null. - Значение параметра или меньше нуля. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - Параметр или имеет отрицательное значение. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. - Исходный размер внутреннего массива в байтах. - Значение отрицательно. - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 2 - - - Возвращает или задает число байтов, выделенных для этого потока. - Длина применимой к использованию части буфера для потока. - Заданная емкость отрицательная или меньше текущей длины потока. - Текущий поток закрыт. - set вызывается для потока, емкость которого нельзя изменить. - 2 - - - Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля. - Токен для отслеживания запросов отмены. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Переопределяет метод так, что никакие действия не выполняются. - 2 - - - Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены. - Поток был ликвидирован. - - - Возвращает длину потока в байтах. - Длина потока в байтах. - Поток закрыт. - 2 - - - Возвращает или задает текущее положение в потоке. - Текущее положение в потоке. - В качестве положения задано отрицательное значение или значение, большее . - Поток закрыт. - 2 - - - Считывает блок байтов из текущего потока и записывает данные в буфер. - Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. - При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом меньше, чем . - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из текущего потока. - Байт приводится к типу или -1, если достигнут конец потока. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для положения в текущем потоке. - Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. - Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. - Значение типа , которое действует как точка ссылки поиска. - Попытка поиска выполняется до начала потока. - Значение больше значения . - - недопустим. -или-Значение вызвало арифметическое переполнение. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для длины текущего потока. - Значение задаваемой длины. - Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. - Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. - 2 - - - Записывает содержимое потока в массив байтов независимо от свойства . - Новый массив байтов. - 2 - - - Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. - Значение true, если преобразование прошло успешно; в противном случае — значение false. - Сегмент массива байтов, из которого был создан данный поток. - - - Записывает в текущий поток блок байтов, используя данные, считанные из буфера. - Буфер, из которого записываются данные. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. - Длина буфера за вычетом меньше, чем . - Параметр или имеет отрицательное значение. - Ошибка ввода-вывода. - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение текущего потока. - Записываемый байт. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. - Текущий поток закрыт. - 2 - - - Записывает все содержимое данного потока памяти в другой поток. - Поток, в который требуется осуществить запись данного потока памяти. - Свойство имеет значение null. - Текущий или конечный поток закрыт. - 2 - - - Задает позицию в потоке, используемую для поиска. - 2 - - - Задает начало потока. - - - Задает текущее положение в потоке. - - - Задает конец потока. - - - Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса . - - - При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. - Значение true, если поток поддерживает чтение; в противном случае — значение false. - 1 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. - Значение true, если поток поддерживает поиск; в противном случае — значение false. - 1 - - - Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. - Значение, которое показывает, может ли для данного потока истечь время ожидания. - 2 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 1 - - - Считывает байты из текущего потока и записывает их в другой поток. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Поток, в который будет скопировано содержимое текущего потока. - Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает все ресурсы, занятые модулем . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. - Ошибка ввода-вывода. - 2 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Поток был ликвидирован. - - - При переопределении в производном классе получает длину потока в байтах. - Длинное значение, представляющее длину потока в байтах. - Класс, созданный на основе класса Stream, не поддерживает возможность поиска. - Методы были вызваны после закрытия потока. - 1 - - - Объект Stream без резервного хранилища. - 1 - - - При переопределении в производном классе получает или задает позицию в текущем потоке. - Текущее положение в потоке. - Ошибка ввода-вывода. - Этот поток не поддерживает поиск. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. - Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. - Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. - Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. - Максимальное количество байтов, которое должно быть считано из текущего потока. - Сумма значений параметров и больше длины буфера. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 1 - - - Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. - Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - При переопределении в производном классе задает позицию в текущем потоке. - Новая позиция в текущем потоке. - Смещение в байтах относительно параметра . - Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. - Ошибка ввода-вывода. - Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе задает длину текущего потока. - Нужная длина текущего потока в байтах. - Ошибка ввода-вывода. - Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 2 - - - При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. - Массив байтов.Этот метод копирует байты из в текущий поток. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Количество байтов, которое необходимо записать в текущий поток. - Сумма  и  больше, чем длина буфера. - - — null. - - или  является отрицательным. - Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. - Поток не поддерживает запись. - - был вызван после закрытия потока. - 1 - - - Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. - Байт, записываемый в поток. - Ошибка ввода-вывода. - Поток не поддерживает запись или был закрыт до начала операции. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 1 - - - Инициализирует новый экземпляр класса для заданного потока. - Поток, который нужно считать. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. - Поток, который нужно считать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - Минимальный размер буфера. - Поток не поддерживает чтение. - Параметр или имеет значение null. - Значение параметра меньше или равно нулю. - - - Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. - Считываемый поток. - Кодировка символов, которую нужно использовать. - Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. - Минимальный размер буфера. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - - - Возвращает основной поток. - Основной поток. - 2 - - - Возвращает текущую кодировку символов, используемую текущим объектом . - Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. - 2 - - - Очищает внутренний буфер. - 2 - - - Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. - Значение true, если текущее положение находится в конце потока; в противном случае — значение false. - Основной поток удален. - 1 - - - Объект для пустого потока. - 1 - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. - Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. - Ошибка ввода-вывода. - 1 - - - Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. - Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Индекс , с которого требуется начать запись. - Максимальное число считываемых символов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Возникает ошибка ввода-вывода, например закрывается поток. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Произошла ошибка ввода-вывода. - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Следующая строка из входного потока или значение null, если достигнут конец входного потока. - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. - Количество символов в следующей строке больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца потока. - Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. - Количество символов больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. - 1 - - - Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Запись в поток запрещена. - - is null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Значение параметра или — null. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . - Значение true, чтобы заставить сбросить буфер; в противном случае — false. - 1 - - - Получает основной поток, связанный с резервным хранилищем. - Поток, в который StreamWriter выполняет запись. - 2 - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. - 2 - - - Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. - Текущее средство записи закрывается. - Произошла ошибка ввода-вывода. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - 1 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает символ в поток. - Символ, записываемый в поток. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток массив символов. - Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток дочерний массив символов. - Массив символов, содержащий записываемые данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток строку. - Строка, записываемая в поток.Если равняется null, запись не выполняется. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает символ в поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, содержащий записываемые данные. - Положение символа в буфере с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает строку в поток. - Задача, представляющая асинхронную операцию записи. - Строка, записываемая в поток.Если имеет значение null, запись не выполняется. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток признак конца строки. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Реализует класс , осуществляющий чтение из строки. - 2 - - - Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. - Строка, для которой должен быть инициализирован класс . - Значение параметра — null. - - - Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. - Текущее средство чтения закрыто. - 2 - - - Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. - Следующий символ из основной строки или значение -1, если больше нет доступных символов. - Текущее средство чтения закрыто. - 2 - - - Считывает блок символов из строки ввода и увеличивает позицию символов на . - Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Начальный индекс в буфере. - Количество символов, которые необходимо считать. - Параметр имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Следующая строка из текущей строки, или значение null, если достигнут конец строки. - Текущее средство чтения закрыто. - Недостаточно памяти для размещения буфера возвращаемых строк. - 2 - - - Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Содержимое, начиная от текущей позиции до конца основной строки. - Недостаточно памяти для размещения буфера возвращаемых строк. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. - Количество символов больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи данных в строку.Данные хранятся в основном . - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным форматом объекта. - Объект , управляющий форматированием. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . - Класс StringBuilder, в который осуществляется запись. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. - Класс StringBuilder, в который осуществляется запись. - Объект , управляющий форматированием. - Параметр имеет значение null. - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Encoding, в которой осуществляется запись выходных данных. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - - - Возвращает основной . - Базовый StringBuilder. - 2 - - - Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. - Строка, содержащая символы, записанные в текущий StringWriter. - 2 - - - Записывает символ в строку. - Символ для записи. - Средство записи закрыто. - 2 - - - Записывает в строку дочерний массив символов. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Значение параметра или является отрицательным. - ( + )> .Length. - Средство записи закрыто. - 2 - - - Записывает строку в текущую строку. - Строка для записи. - Средство записи закрыто. - 2 - - - Выполняет асинхронную запись символа в строку. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в строку. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текущую строку. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в строку символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Представляет средство чтения, позволяющее считывать последовательные наборы символов. - 2 - - - Инициализирует новый экземпляр класса . - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Предоставляет TextReader без данных, доступных для чтения. - 1 - - - Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. - Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. - При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. - Следующая строка из средства чтения, или значение null, если все символы считаны. - Ошибка ввода-вывода. - Недостаточно памяти для размещения буфера возвращаемых строк. - Объект закрыт. - Количество символов в следующей строке больше . - 1 - - - Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. - Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. - Ошибка ввода-вывода. - Объект закрыт. - Недостаточно памяти для размещения буфера возвращаемых строк. - Количество символов в следующей строке больше . - 1 - - - Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. - Количество символов больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса указанным поставщиком формата. - Объект , управляющий форматированием. - - - Сохраняет символы новой строки, используемые для данного TextWriter. - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. - Кодировка символов, в которой осуществляется запись выходных данных. - 1 - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Удалено средство записи текста. - Средство записи в настоящее время используется предыдущей операцией записи. - - - Возвращает объект, управляющий форматированием. - Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. - 2 - - - Возвращает или задает признак конца строки, используемой текущим TextWriter. - Признак конца строки для текущего TextWriter. - 2 - - - Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись символа в текстовую строку или поток. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись массива символов в текстовую строку или поток. - Массив символов, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает дочерний массив символов в текстовую строку или поток. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает текстовое представление десятичного значения в текстовую строку или поток. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. - Записываемый объект. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает строку в текстовую строку или поток. - Строка для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Параметр или имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет асинхронную запись символа в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись массива символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Записывает признак конца строки в текстовую строку или поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Положение символа в , с которого начинается чтение данных. - Наибольшее количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. - Записываемый объект.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток строку, за которой следует признак конца строки. - Строка для записи.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Строка или объект передаются в виде null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает признак конца строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml deleted file mode 100644 index cf7eb52f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hans/System.IO.xml +++ /dev/null @@ -1,2237 +0,0 @@ - - - - System.IO - - - - 用特定的编码将基元数据类型读作二进制值。 - 2 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输入流。 - 该流不支持读取，为null 或已关闭。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输入流。 - 要使用的字符编码。 - 该流不支持读取，为null 或已关闭。 - - 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输入流。 - 要使用的字符编码。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - 该流不支持读取，为null 或已关闭。 - - 或 为 null。 - - - 公开对 的基础流的访问。 - 与 BinaryReader 关联的基础流。 - 2 - - - 释放 类的当前实例所使用的所有资源。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 用从流中读取的指定字节数填充内部缓冲区。 - 要读取的字节数。 - 在可以读取 之前到达了流的末尾。 - 发生 I/O 错误。 - 请求的 大于内部缓冲区大小。 - - - 返回下一个可用的字符，并且不提升字节或字符的位置。 - 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 - 发生 I/O 错误。 - 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 - 2 - - - 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 输入流中的下一个字符，如果当前无可用字符则为 -1。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 从字节数组中的指定点开始，从流中读取指定的字节数。 - 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字节数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从字符数组中的指定点开始，从流中读取指定的字符数。 - 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字符数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 以压缩格式读入 32 位整数。 - 压缩格式的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 流已损坏。 - - - 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 - 如果字节为非零，则为 true，否则为 false。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的下一个字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 - 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 发生 I/O 错误。 - 流已关闭。 - - 为负数。 - 2 - - - 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 从当前流中读取的字符。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 读取了一个代理项字符。 - 2 - - - 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 - 要读取的字符数。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 流已关闭。 - 发生 I/O 错误。 - - 为负数。 - 2 - - - 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 - 从当前流中读取的十进制数值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的一个有符号字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 4 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 - 正被读取的字符串。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 - 从该流中读取的 2 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 - 从该流中读取的 4 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 - 从该流中读取的 8 字节无符号整数。 - 已到达流的末尾。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 - 2 - - - 初始化向流中写入的 类的新实例。 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输出流。 - 该流不支持写入或者该流已关闭。 - - 为 null。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输出流。 - 要使用的字符编码。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输出流。 - 要使用的字符编码。 - 如果在释放 对象之后打开流对象，则为 true；否则为， false。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 获取 的基础流。 - 与 BinaryWriter 关联的基础流。 - 1 - - - 释放由 类的当前实例占用的所有资源。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 指定无后备存储区的 。 - 1 - - - 持有基础流。 - - - 设置当前流中的位置。 - 包含当前流的位置。 - 相对于 的字节偏移量。 - - 的一个字段，指示获取新位置所依据的参考点。 - 文件指针被移到无效位置。 - - 值无效。 - 1 - - - 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 - 要写入的 Boolean 值（0 或 1）。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的无符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将字节数组写入基础流。 - 包含要写入的数据的字节数组。 - 发生 I/O 错误。 - 流已关闭。 - - 为 null。 - 1 - - - 将字节数组部分写入当前流。 - 包含要写入的数据的字节数组。 - - 中开始写入的起始点。 - 要写入的字节数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 要写入的非代理项 Unicode 字符。 - 发生 I/O 错误。 - 流已关闭。 - - 是单一代理项字符。 - 1 - - - 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 为 null。 - 流已关闭。 - 发生 I/O 错误。 - 1 - - - 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 中开始写入的起始点。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个十进制值写入当前流，并将流位置提升十六个字节。 - 要写入的十进制值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的有符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 - 要写入的值。 - 发生 I/O 错误。 - - 为 null。 - 流已关闭。 - 1 - - - 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 以压缩格式写出 32 位整数。 - 要写出的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 流已关闭。 - - - 读操作试图超出流的末尾时引发的异常。 - 2 - - - 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - - - 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - - - 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 在数据流的格式无效时引发的异常。 - - - 初始化 类的新实例。 - - - 使用指定的错误消息初始化 类的新实例。 - 解释异常原因的错误信息。 - - - 用对作为此异常原因的内部异常的引用初始化 类的新实例。 - 解释异常原因的错误信息。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化为零的可扩展容量初始化 类的新实例。 - - - 基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建当前流的无符号字节数组。 - - 为 null。 - - - 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - - 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 为 null。 - - 或 小于零。 - 缓冲区长度减去 小于 。 - - - 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 使用按指定要求初始化的可扩展容量初始化 类的新实例。 - 内部数组的初始大小（以字节为单位）。 - - 为负数。 - - - 获取一个值，该值指示当前流是否支持读取。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持查找。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持写入。 - 如果流支持写入，则为 true；否则为 false。 - 2 - - - 获取或设置分配给该流的字节数。 - 流的缓冲区的可使用部分的长度。 - 容量设置为负或小于流的当前长度。 - 当前流已关闭。 - 对不能修改其容量的流调用 set。 - 2 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。 - 要监视取消请求的标记。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 重写 方法以便不执行任何操作。 - 2 - - - 异步清除此流的所有缓冲区，并监视取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。 - 流已被释放。 - - - 获取流的长度（以字节为单位）。 - 流的长度（以字节为单位）。 - 流已关闭。 - 2 - - - 获取或设置流中的当前位置。 - 流中的当前位置。 - 此位置设置为负值或大于 的值。 - 流已关闭。 - 2 - - - 从当前流中读取字节块并将数据写入缓冲区。 - 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 - 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 - - 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 的结果小于 。 - 当前流实例已关闭。 - 2 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流中读取一个字节。 - 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 - 当前流实例已关闭。 - 2 - - - 将当前流中的位置设置为指定值。 - 流内的新位置，通过将初始引用点和偏移量合并计算而得。 - 流内的新位置。它是相对于 参数的位置，而且可正可负。 - 类型 的值，它用作查找引用点。 - 试图在流的开始位置之前查找。 - - 大于 。 - - 无效。- 或 - 导致算法溢出。 - 当前流实例已关闭。 - 2 - - - 将当前流的长度设为指定值。 - 用于设置长度的值。 - 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 - - 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 - 2 - - - 将流内容写入字节数组，而与 属性无关。 - 新的字节数组。 - 2 - - - 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 - 如果转换成功，则为 true；否则为 false。 - 用于创建此流的字节数组段。 - - - 使用从缓冲区读取的数据将字节块写入当前流。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 最多写入的字节数。 - - 为 null。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 - 缓冲区长度减去 的结果小于 。 - - 或 为负。 - 发生 I/O 错误。 - 当前流实例已关闭。 - 2 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入当前位置上的当前流。 - 要写入的字节。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 - 当前流已关闭。 - 2 - - - 将此内存流的整个内容写入到另一个流中。 - 要写入此内存流的流。 - - 为 null。 - 当前流或目标流已关闭。 - 2 - - - 指定在流的位置以查找使用。 - 2 - - - 指定流的开头。 - - - 指定流内的当前位置。 - - - 指定流的结尾。 - - - 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 类的新实例。 - - - 当在派生类中重写时，获取指示当前流是否支持读取的值。 - 如果流支持读取，为 true；否则为 false。 - 1 - - - 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 - 如果流支持查找，为 true；否则为 false。 - 1 - - - 获取一个值，该值确定当前流是否可以超时。 - 一个确定当前流是否可以超时的值。 - 2 - - - 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 - 如果流支持写入，则为 true；否则为 false。 - 1 - - - 从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - 缓冲区的大小。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放由 使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 - 发生 I/O 错误。 - 2 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。默认值为 。 - 流已被释放。 - - - 当在派生类中重写时，获取流长度（以字节为单位）。 - 表示流长度（以字节为单位）的长值。 - 从 Stream 派生的类不支持查找。 - 在流关闭后调用方法。 - 1 - - - 无后备存储区的 Stream。 - 1 - - - 当在派生类中重写时，获取或设置当前流中的位置。 - 流中的当前位置。 - 发生 I/O 错误。 - 流不支持查找。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 - 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 - 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 - - 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 - 要从当前流中最多读取的字节数。 - - 与 的和大于缓冲区长度。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流不支持读取。 - 在流关闭后调用方法。 - 1 - - - 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 - 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 - 流不支持读取。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 - 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 当在派生类中重写时，设置当前流中的位置。 - 当前流中的新位置。 - 相对于 参数的字节偏移量。 - - 类型的值，指示用于获取新位置的参考点。 - 发生 I/O 错误。 - 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，设置当前流的长度。 - 所需的当前流的长度（以字节表示）。 - 发生 I/O 错误。 - 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 2 - - - 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 - 字节数组。此方法将 个字节从 复制到当前流。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 要写入当前流的字节数。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 流不支持写入。 - - 流关闭后调用。 - 1 - - - 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 - 要写入流中的字节。 - 发生 I/O 错误。 - 该流不支持写入，或者该流已关闭。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 - 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 为指定的流初始化 类的新实例。 - 要读取的流。 - - 不支持读取。 - - 为 null。 - - - 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 - 要读取的流。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 为 null。 - - - 用指定的字符编码为指定的流初始化 类的一个新实例。 - 要读取的流。 - 要使用的字符编码。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - 最小缓冲区大小。 - 流不支持读取。 - - 或 为 null。 - - 小于或等于零。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 - 要读取的流。 - 要使用的字符编码。 - 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 - 最小缓冲区大小。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - - - 返回基础流。 - 基础流。 - 2 - - - 获取当前 对象正在使用的当前字符编码。 - 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 - 2 - - - 清除内部缓冲区。 - 2 - - - 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 获取一个值，该值指示当前的流位置是否在流结尾。 - 如果当前流位置位于流的末尾，则为 true；否则为 false。 - 基础流已释放。 - 1 - - - 空流周围的 。 - 1 - - - 返回下一个可用字符，但不使用它。 - 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 - 发生 I/O 错误。 - 1 - - - 读取输入流中的下一个字符并使该字符位置提升一个字符。 - 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 - 发生 I/O 错误。 - 1 - - - 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 - 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 开始写入的 的索引。 - 要读取的最大字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 出现 I/O 错误，如流被关闭。 - 1 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生了 I/O 错误。 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取一行字符并将数据作为字符串返回。 - 输入流中的下一行；如果到达了输入流的末尾，则为 null。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 从当前流中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 - 下一行中的字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取来自流的当前位置到结尾的所有字符。 - 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 - 字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 - 1 - - - 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 - 要写入的流。 - - 不可写。 - - 为 null。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - - 或 为 null。 - - 不可写。 - - - 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - true to leave the stream open after the object is disposed; otherwise, false. - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 - 强制 刷新其缓冲区时，为 true；否则，为 false。 - 1 - - - 获取同后备存储连接的基础流。 - 此 StreamWriter 正在写入的基础流。 - 2 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - 当前编码不支持显示半个 Unicode 代理项对。 - - - 获取将输出写入到其中的 。 - 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 - 2 - - - 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 - 当前编写器已关闭。 - 出现 I/O 错误。 - 当前编码不支持显示半个 Unicode 代理项对。 - 1 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将字符写入流。 - 要写入流中的字符。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符数组写入流。 - 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符的子数组写入流。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符串写入流。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 发生 I/O 错误。 - 1 - - - 将字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将行终止符异步写入该流。 - 表示异步写操作的任务。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 实现从字符串进行读取的 。 - 2 - - - 初始化从指定字符串进行读取的 类的新实例。 - 应将 初始化为的字符串。 - - 参数为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 返回下一个可用的字符，但不使用它。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 - 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的字符块，并将字符位置提升 。 - 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 缓存区中的起始索引。 - 要读取的字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 当前读取器已关闭。 - 2 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前字符串中读取一行字符并将数据作为字符串返回。 - 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 - 当前读取器已关闭。 - 内存不足，无法为返回的字符串分配缓冲区。 - 2 - - - 从当前字符串中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 从当前位置到基础字符串的结尾之间的内容。 - 内存不足，无法为返回的字符串分配缓冲区。 - 当前读取器已关闭。 - 2 - - - 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 - 字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式控制初始化 类的新实例。 - 控制格式设置的 对象。 - - - 初始化写入指定 的 类的新实例。 - 要写入的 StringBuilder。 - - 为 null。 - - - 初始化写入指定 并具有指定格式提供程序的 类的新实例。 - 要写入的 StringBuilder。 - 控制格式设置的 对象。 - - 为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 获取将输出写入到其中的 。 - 用来写入输出的 Encoding。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - - - 返回基础 。 - 基础 StringBuilder。 - 2 - - - 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 - 包含写入到当前 StringWriter 中的字符的字符串。 - 2 - - - 将字符写入该字符串。 - 要写入的字符。 - 编写器已关闭。 - 2 - - - 将字符的子数组写入该字符串。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - 或 为负。 - ( + )> 。Length. - 编写器已关闭。 - 2 - - - 将字符串写入当前流。 - 要写入的字符串。 - 编写器已关闭。 - 2 - - - 以异步方式将字符写入流。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将字符串写入当前流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将后跟行结束符的字符写入该字符串。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将一后跟行结束符的字符串异步写入当前字符串。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 表示可读取有序字符系列的读取器。 - 2 - - - 初始化 类的新实例。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - 提供一个无数据可供读取的 TextReader。 - 1 - - - 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 - 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 - 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 2 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从文本读取器中读取一行字符并将数据作为字符串返回。 - 读取器中的下一行，或为 null （如果已读取了所有字符）。 - 发生 I/O 错误。 - 内存不足，无法为返回的字符串分配缓冲区。 - - 是关闭的。 - 下一行中的字符数大于 - 1 - - - 异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 - 发生 I/O 错误。 - - 是关闭的。 - 内存不足，无法为返回的字符串分配缓冲区。 - 下一行中的字符数大于 - 1 - - - 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 - 字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 表示可以编写一个有序字符系列的编写器。此类为抽象类。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式提供程序初始化 类的新实例。 - 控制格式设置的 对象。 - - - 存储用于此 TextWriter 的换行符。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，返回用来写输出的该字符编码。 - 用来写入输出的字符编码。 - 1 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - 文本编写器已被释放。 - 编写器正在由其前一次写操作使用。 - - - 获取控制格式设置的对象。 - 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 - 2 - - - 获取或设置由当前 TextWriter 使用的行结束符字符串。 - 当前 TextWriter 的行结束符字符串。 - 2 - - - 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符写入该文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符数组写入该文本字符串或流。 - 要写入文本流中的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符的子数组写入文本字符串或流。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符串写入到文本字符串或流。 - 要写入的字符串。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - - 或 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符写入到下一个文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符数组写入到下一个字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符串写入到下一字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将行结束符的字符串写入文本字符串或流。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符写入文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符数组写入文本字符串或流。 - 从其读取数据的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符子数组写入文本字符串或流。 - 从其读取数据的字符数组。 - 在开始读取数据时 中的字符位置。 - 要写入的最大字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符串写入文本字符串或流。 - 要写入的字符串。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - 字符串或对象作为 null 传入。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml deleted file mode 100644 index 26192a9d..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.3/zh-hant/System.IO.xml +++ /dev/null @@ -1,2246 +0,0 @@ - - - - System.IO - - - - 以特定的編碼方式，將基本資料型別當做二進位值讀取。 - 2 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸入資料流。 - 資料流不支援讀取，為 null，或已經關閉。 - - - 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 - 輸入資料流。 - 要使用的字元編碼。 - 資料流不支援讀取，為 null，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 - 輸入資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - 資料流不支援讀取，為 null，或已經關閉。 - - 或 為 null。 - - - 公開 之基礎資料流的存取。 - 與 BinaryReader 相關聯的基礎資料流。 - 2 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 將從資料流讀取的指定位元組數目填入內部緩衝區。 - 要讀取的位元組數。 - 在 可讀取之前到達資料流末端。 - 發生 I/O 錯誤。 - 所要求的 大於內部緩衝區大小。 - - - 傳回下一個可用字元，而不前移位元組或字元的位置。 - 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 - 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 - 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的位元組數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 由字元陣列中的指定點開始，從資料流讀取指定字元數。 - 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的字元數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以壓縮格式讀取 32 位元整數。 - 壓縮格式的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 資料流已損毀。 - - - 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 - 如果位元組為非零值，則為 true；否則為 false。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 - 自目前資料流讀取的下一個位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 - 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 - 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為負值。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 - 自目前資料流讀取的字元。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 讀取到 Surrogate 字元 - 2 - - - 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 - 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 - 要讀取的字元數。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 已關閉資料流。 - 發生 I/O 錯誤。 - - 為負值。 - 2 - - - 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 - 自目前資料流讀取的十進位值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自目前資料流讀取的 2 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 - 自資料流讀取的帶正負號的位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 - 讀取的字串。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自這個資料流讀取 2 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自這個資料流讀取 4 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自這個資料流讀取 8 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 - 2 - - - 初始化 類別的新執行個體，其將寫入資料流。 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 資料流不支援寫入，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 要使用的字元編碼。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 輸出資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 取得 的基礎資料流。 - 與 BinaryWriter 相關聯的基礎資料流。 - 1 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 指定沒有備份存放區的 。 - 1 - - - 容納基礎資料流。 - - - 設定目前資料流位置。 - 目前資料流的位置。 - 相對於 的位元組位移。 - - 的欄位，表示要取得新位置的參考點。 - 檔案指標已移至無效的位置。 - - 值是無效的。 - 1 - - - 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 - 要寫入的 Boolean 值 (0 或 1)。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的不帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將位元組陣列寫入基礎資料流。 - 含有要寫入之資料的位元組陣列。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為 null。 - 1 - - - 將一個區域的位元組陣列寫入目前資料流。 - 含有要寫入之資料的位元組陣列。 - - 中要開始寫入的起始點。 - 要寫入的位元組數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 非 Surrogate，要寫入的 Unicode 字元。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 是單一 Surrogate 字元。 - 1 - - - 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 為 null。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 中要開始寫入的起始點。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 - 要寫入的十進位值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 要寫入的值。 - 發生 I/O 錯誤。 - - 為 null。 - 已關閉資料流。 - 1 - - - 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組不帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 以壓縮格式寫入 32 位元整數。 - 要寫入的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 已關閉資料流。 - - - 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 - 2 - - - 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - - - 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - - - 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 資料流在格式無效時擲回的例外狀況。 - - - 初始化 類別的新執行個體。 - - - 使用指定的錯誤訊息，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - - - 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 - - - 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 - 用於建立目前資料流之不帶正負號位元組的陣列。 - - 為 null。 - - - 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - - 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 為 null。 - - 或 小於零。 - 緩衝區長度減去 小於 。 - - - 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 - 內部陣列的初始大小，以位元組為單位。 - - 為負值。 - - - 取得表示目前資料流是否支援讀取的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援搜尋的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援寫入的值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 2 - - - 取得或設定配置給這個資料流的位元組數目。 - 資料流緩衝區可使用部分的長度。 - 設定的容量為負數或小於資料流目前的長度。 - 目前的資料流已經關閉。 - set 在無法修改其容量的資料流上被叫用 (Invoke)。 - 2 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 - 用來監視是否有取消要求的語彙基元。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 覆寫 方法，以便不執行任何動作。 - 2 - - - 非同步清除這個資料流的所有緩衝區，並監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。 - 已處置資料流。 - - - 取得資料流的長度，以位元組為單位。 - 資料流的長度，以位元組為單位。 - 已關閉資料流。 - 2 - - - 取得或設定資料流中目前的位置。 - 在資料流的目前位置。 - 位置設為負數值或大於 的值。 - 已關閉資料流。 - 2 - - - 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 - 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 - - 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - 緩衝區的長度減去 小於 。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從目前的資料流讀取位元組。 - 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流中的位置設定為指定的數值。 - 資料流中的新位置，是組合初始的參考點和位移計算出來的。 - 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 - - 類型的值，做為搜尋參考點。 - 在資料流開頭之前嘗試搜尋。 - - 大於 。 - 有無效的 。-或- 造成了算術溢位。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流的長度設定為指定的數值。 - 要設定長度的數值。 - 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 - - 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 - 2 - - - 不論 屬性為何，將資料流內容寫入位元組陣列。 - 新的位元組陣列。 - 2 - - - 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 - 如果轉換成功，則為 true；否則為 false。 - 從其中建立此資料流的位元組陣列區段。 - - - 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入的最大位元組數。 - - 為 null。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 - 緩衝區的長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入位元組至資料流目前位置。 - 要寫入的位元組。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 - 目前的資料流已經關閉。 - 2 - - - 將這個記憶體資料流的整個內容寫入另一個資料流。 - 要寫入這個記憶體資料流的資料流。 - - 為 null。 - 目前的資料流或目標資料流已經關閉。 - 2 - - - 指定資料流中要用於搜尋的位置。 - 2 - - - 指定資料流的開端。 - - - 指定資料流中的目前位置。 - - - 指定資料流的末端。 - - - 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 類別的新執行個體。 - - - 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 - 如果資料流支援讀取，則為 true；否則為 false。 - 1 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 - 如果資料流支援搜尋，則為 true；否則為 false。 - 1 - - - 取得值，該值判斷目前的資料流是否可以逾時。 - 值，判斷目前的資料流是否可以逾時。 - 2 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 1 - - - 從目前資料流讀取位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 所使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 發生 I/O 錯誤。 - 2 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 已處置資料流。 - - - 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - 已處置資料流。 - - - 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 - 代表資料流長度的長數值 (以位元組為單位)。 - 衍生自 Stream 的類別不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 沒有底層存放區的 Stream。 - 1 - - - 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 - 在資料流的目前位置。 - 發生 I/O 錯誤。 - 資料流不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 - 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 - 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 - - 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 - 自目前資料流讀取的最大位元組數。 - - 和 的總和大於緩衝區的長度。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 - 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - - 方法必須擲回 。 - 2 - - - 在衍生類別中覆寫時，設定在目前資料流的位置。 - 目前資料流的新位置。 - 相對於 參數的位元組位移。 - - 類型的值，表示用來取得新位置的參考點。 - 發生 I/O 錯誤。 - 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 在衍生類別中覆寫時，設定目前資料流的長度。 - 想要的目前資料流長度 (單位為位元組)。 - 發生 I/O 錯誤。 - 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 - 位元組陣列。此方法會從 複製 位元組到目前資料流。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入目前資料流的位元組數目。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 資料流不支援寫入。 - - 流关闭后调用。 - 1 - - - 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 - 寫入資料流的位元組。 - 發生 I/O 錯誤。 - 資料流不支援寫入，或資料流已經關閉。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - - 方法必須擲回 。 - 2 - - - 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 為指定的資料流，初始化 類別的新執行個體。 - 要讀取的資料流。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - 最小緩衝區大小。 - 資料流不支援讀取。 - - 或 為 null。 - - 小於或等於零值。 - - - 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要讀取的資料流。 - 要使用的字元編碼。 - true 表示在檔案開頭尋找位元順序標記；否則為 false。 - 最小緩衝區大小。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - - - 傳回基礎資料流。 - 基礎資料流。 - 2 - - - 取得目前 物件使用的目前字元編碼。 - 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 - 2 - - - 清除內部緩衝區。 - 2 - - - 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得表示現行資料流位置是否在資料流結尾的值。 - 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 - 已處置基礎資料流。 - 1 - - - 空資料流周圍的 物件。 - 1 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 1 - - - 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 - 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 - 發生 I/O 錯誤。 - 1 - - - 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 - 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - 要開始寫入的 的索引。 - 要讀取的字元數上限。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤，例如資料流已經關閉。 - 1 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前資料流讀取一行字元，並將資料以字串傳回。 - 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 - 下一行中的字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到資料流末端的所有字元。 - 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 - 字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 - 1 - - - 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - - 不可寫入。 - - 為 null。 - - - 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - - 或 是 null。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 - 強制 清除其緩衝區，則為 true，否則為 false。 - 1 - - - 取得以備份存放區作介面的基礎資料流。 - StreamWriter 正在寫入的資料流。 - 2 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - - - 取得寫入輸出的 。 - - (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 - 2 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 - 目前寫入器已關閉。 - 發生 I/O 錯誤。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - 1 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - 已處置資料流。 - - - 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將一個字元寫入資料流。 - 要寫入資料流的字元。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元陣列寫入資料流。 - 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元子陣列寫入資料流。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字串寫入資料流。 - 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入資料流。 - 表示非同步寫入作業的工作。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 將行結束字元以非同步方式寫入資料流。 - 表示非同步寫入作業的工作。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 實作讀取字串的 。 - 2 - - - 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 - - 應該初始化的目的字串。 - - 參數為 null。 - - - 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 - 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 - 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - 緩衝區中的起始索引。 - 要讀取的字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負數。 - 目前的讀取器已關閉。 - 2 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前字串讀取一行字元，並將資料以字串傳回。 - 目前字串的下一行，如果已到達字串的結尾，則為 null。 - 目前的讀取器已關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 2 - - - 自目前字串非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 基礎字串從目前位置至結尾的內容。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 目前的讀取器已關閉。 - 2 - - - 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 - 字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的控制項格式，初始化 類別的新執行個體。 - 控制格式的 物件。 - - - 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 - 要寫入至其中的 StringBuilder。 - - 為 null。 - - - 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 - 要寫入至其中的 StringBuilder。 - 控制格式的 物件。 - - 為 null。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得寫入輸出的 。 - 寫入輸出的 Encoding。 - 1 - - - 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - - - 傳回基礎 。 - 基礎 StringBuilder。 - 2 - - - 傳回字串，包含被寫入至目前 StringWriter 的字元。 - 字串，包含被寫入至目前 StringWriter 的字元。 - 2 - - - 將一個字元寫入至字串。 - 要寫入的字元。 - 寫入器關閉。 - 2 - - - 將字元子陣列寫入至字串。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 或 為負數。 - ( + )> 。Length. - 寫入器關閉。 - 2 - - - 將字串寫入至目前字串。 - 要寫入的字串。 - 寫入器關閉。 - 2 - - - 以非同步方式將字元寫入至字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入至字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入至目前字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 代表可以讀取一連串連續字元的讀取器 (Reader)。 - 2 - - - 初始化 類別的新執行個體。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 提供未讀取資料的 TextReader。 - 1 - - - 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 - 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 2 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自文字讀取器讀取一行字元，並將資料以字串傳回。 - 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 - 發生 I/O 錯誤。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - - 已經關閉。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 字串，包含從目前位置到文字讀取器結尾的所有字元。 - 發生 I/O 錯誤。 - - 已經關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 - 字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的格式提供者，初始化 類別的新執行個體。 - 控制格式設定的 物件。 - - - 儲存這個 TextWriter 所使用的新行字元。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 - 寫入輸出時使用的字元編碼。 - 1 - - - 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 文字寫入器已處置。 - 寫入器目前由先前寫入作業所使用。 - - - 取得控制格式設定的物件。 - 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 - 2 - - - 取得或設定目前 TextWriter 所使用的行結束字元字串。 - 目前 TextWriter 的行結束字元字串。 - 2 - - - 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將 Boolean 值的文字表示寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列寫入到文字字串或資料流。 - 要寫入到文字資料流的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元的子陣列寫入到文字字串或資料流。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 - 要寫入的物件。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串寫入到文字字串或資料流。 - 要寫入的字串。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - - 或 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 將行結束字元寫入到文字字串或資料流。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 中開始讀取資料的字元位置。 - 要寫入的最大字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的物件。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入的字串。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - 傳入的字串或物件為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將行結束字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.dll b/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.dll deleted file mode 100644 index ddd816f645b552c98870e5030da2448f0ee46325..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 30528 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 diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml deleted file mode 100644 index 94677abb..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Reads primitive data types as binary values in a specific encoding. - 2 - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The input stream. - The stream does not support reading, is null, or is already closed. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The input stream. - The character encoding to use. - The stream does not support reading, is null, or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The input stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support reading, is null, or is already closed. - - or is null. - - - Exposes access to the underlying stream of the . - The underlying stream associated with the BinaryReader. - 2 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Fills the internal buffer with the specified number of bytes read from the stream. - The number of bytes to be read. - The end of the stream is reached before could be read. - An I/O error occurs. - Requested is larger than the internal buffer size. - - - Returns the next available character and does not advance the byte or character position. - The next available character, or -1 if no more characters are available or the stream does not support seeking. - An I/O error occurs. - The current character cannot be decoded into the internal character buffer by using the selected for the stream. - 2 - - - Reads characters from the underlying stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - The next character from the input stream, or -1 if no characters are currently available. - An I/O error occurs. - The stream is closed. - 2 - - - Reads the specified number of bytes from the stream, starting from a specified point in the byte array. - The number of bytes read into . This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of bytes to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of characters from the stream, starting from a specified point in the character array. - The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached. - The buffer to read data into. - The starting point in the buffer at which to begin reading into the buffer. - The number of characters to read. - The buffer length minus is less than . -or-The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - - is null. - - or is negative. - The stream is closed. - An I/O error occurs. - 2 - - - Reads in a 32-bit integer in compressed format. - A 32-bit integer in compressed format. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - The stream is corrupted. - - - Reads a Boolean value from the current stream and advances the current position of the stream by one byte. - true if the byte is nonzero; otherwise, false. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the next byte from the current stream and advances the current position of the stream by one byte. - The next byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes. - A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached. - The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - An I/O error occurs. - The stream is closed. - - is negative. - 2 - - - Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. - A character read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - A surrogate character was read. - 2 - - - Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. - A character array containing data read from the underlying stream. This might be less than the number of characters requested if the end of the stream is reached. - The number of characters to read. - The number of decoded characters to read is greater than . This can happen if a Unicode decoder returns fallback characters or a surrogate pair. - The stream is closed. - An I/O error occurs. - - is negative. - 2 - - - Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. - A decimal value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. - An 8-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. - A 2-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. - A 4-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. - An 8-byte signed integer read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a signed byte from this stream and advances the current position of the stream by one byte. - A signed byte read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. - A 4-byte floating point value read from the current stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. - The string being read. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes. - A 2-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes. - A 4-byte unsigned integer read from this stream. - The end of the stream is reached. - The stream is closed. - An I/O error occurs. - 2 - - - Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes. - An 8-byte unsigned integer read from this stream. - The end of the stream is reached. - An I/O error occurs. - The stream is closed. - 2 - - - Writes primitive types in binary to a stream and supports writing strings in a specific encoding. - 2 - - - Initializes a new instance of the class that writes to a stream. - - - Initializes a new instance of the class based on the specified stream and using UTF-8 encoding. - The output stream. - The stream does not support writing or is already closed. - - is null. - - - Initializes a new instance of the class based on the specified stream and character encoding. - The output stream. - The character encoding to use. - The stream does not support writing or is already closed. - - or is null. - - - Initializes a new instance of the class based on the specified stream and character encoding, and optionally leaves the stream open. - The output stream. - The character encoding to use. - true to leave the stream open after the object is disposed; otherwise, false. - The stream does not support writing or is already closed. - - or is null. - - - Gets the underlying stream of the . - The underlying stream associated with the BinaryWriter. - 1 - - - Releases all resources used by the current instance of the class. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Specifies a with no backing store. - 1 - - - Holds the underlying stream. - - - Sets the position within the current stream. - The position with the current stream. - A byte offset relative to . - A field of indicating the reference point from which the new position is to be obtained. - The file pointer was moved to an invalid location. - The value is invalid. - 1 - - - Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. - The Boolean value to write (0 or 1). - An I/O error occurs. - The stream is closed. - 1 - - - Writes an unsigned byte to the current stream and advances the stream position by one byte. - The unsigned byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a byte array to the underlying stream. - A byte array containing the data to write. - An I/O error occurs. - The stream is closed. - - is null. - 1 - - - Writes a region of a byte array to the current stream. - A byte array containing the data to write. - The starting point in at which to begin writing. - The number of bytes to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - The non-surrogate, Unicode character to write. - An I/O error occurs. - The stream is closed. - - is a single surrogate character. - 1 - - - Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. - A character array containing the data to write. - - is null. - The stream is closed. - An I/O error occurs. - 1 - - - Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. - A character array containing the data to write. - The starting point in from which to begin writing. - The number of characters to write. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a decimal value to the current stream and advances the stream position by sixteen bytes. - The decimal value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. - The eight-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. - The two-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. - The four-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. - The eight-byte signed integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a signed byte to the current stream and advances the stream position by one byte. - The signed byte to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. - The four-byte floating-point value to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a length-prefixed string to this stream in the current encoding of the , and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. - The value to write. - An I/O error occurs. - - is null. - The stream is closed. - 1 - - - Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. - The two-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. - The four-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. - The eight-byte unsigned integer to write. - An I/O error occurs. - The stream is closed. - 1 - - - Writes a 32-bit integer in a compressed format. - The 32-bit integer to be written. - The end of the stream is reached. - The stream is closed. - The stream is closed. - - - The exception that is thrown when reading is attempted past the end of a stream. - 2 - - - Initializes a new instance of the class with its message string set to a system-supplied message and its HRESULT set to COR_E_ENDOFSTREAM. - - - Initializes a new instance of the class with its message string set to and its HRESULT set to COR_E_ENDOFSTREAM. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - - - Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. - A string that describes the error. The content of is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - The exception that is thrown when a data stream is in an invalid format. - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with a specified error message. - The error message that explains the reason for the exception. - - - Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. - The error message that explains the reason for the exception. - The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. - - - Creates a stream whose backing store is memory.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class with an expandable capacity initialized to zero. - - - Initializes a new non-resizable instance of the class based on the specified byte array. - The array of unsigned bytes from which to create the current stream. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified byte array with the property set as specified. - The array of unsigned bytes from which to create this stream. - The setting of the property, which determines whether the stream supports writing. - - is null. - - - Initializes a new non-resizable instance of the class based on the specified region (index) of a byte array. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - - is null. - - or is less than zero. - The buffer length minus is less than . - - - Initializes a new non-resizable instance of the class based on the specified region of a byte array, with the property set as specified. - The array of unsigned bytes from which to create this stream. - The index in at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - - is null. - - or are negative. - The buffer length minus is less than . - - - Initializes a new instance of the class based on the specified region of a byte array, with the property set as specified, and the ability to call set as specified. - The array of unsigned bytes from which to create this stream. - The index into at which the stream begins. - The length of the stream in bytes. - The setting of the property, which determines whether the stream supports writing. - true to enable , which returns the unsigned byte array from which the stream was created; otherwise, false. - - is null. - - or is negative. - The buffer length minus is less than . - - - Initializes a new instance of the class with an expandable capacity initialized as specified. - The initial size of the internal array in bytes. - - is negative. - - - Gets a value indicating whether the current stream supports reading. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports seeking. - true if the stream is open. - 2 - - - Gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 2 - - - Gets or sets the number of bytes allocated for this stream. - The length of the usable portion of the buffer for the stream. - A capacity is set that is negative or less than the current length of the stream. - The current stream is closed. - set is invoked on a stream whose capacity cannot be modified. - 2 - - - Asynchronously reads all the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. - The token to monitor for cancellation requests. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases the unmanaged resources used by the class and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Overrides the method so that no action is performed. - 2 - - - Asynchronously clears all buffers for this stream, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. - The stream has been disposed. - - - Gets the length of the stream in bytes. - The length of the stream in bytes. - The stream is closed. - 2 - - - Gets or sets the current position within the stream. - The current position within the stream. - The position is set to a negative value or a value greater than . - The stream is closed. - 2 - - - Reads a block of bytes from the current stream and writes the data to a buffer. - The total number of bytes written into the buffer. This can be less than the number of bytes requested if that number of bytes are not currently available, or zero if the end of the stream is reached before any bytes are read. - When this method returns, contains the specified byte array with the values between and ( + - 1) replaced by the characters read from the current stream. - The zero-based byte offset in at which to begin storing data from the current stream. - The maximum number of bytes to read. - - is null. - - or is negative. - - subtracted from the buffer length is less than . - The current stream instance is closed. - 2 - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the current stream. - The byte cast to a , or -1 if the end of the stream has been reached. - The current stream instance is closed. - 2 - - - Sets the position within the current stream to the specified value. - The new position within the stream, calculated by combining the initial reference point and the offset. - The new position within the stream. This is relative to the parameter, and can be positive or negative. - A value of type , which acts as the seek reference point. - Seeking is attempted before the beginning of the stream. - - is greater than . - There is an invalid . -or- caused an arithmetic overflow. - The current stream instance is closed. - 2 - - - Sets the length of the current stream to the specified value. - The value at which to set the length. - The current stream is not resizable and is larger than the current capacity.-or- The current stream does not support writing. - - is negative or is greater than the maximum length of the , where the maximum length is( - origin), and origin is the index into the underlying buffer at which the stream starts. - 2 - - - Writes the stream contents to a byte array, regardless of the property. - A new byte array. - 2 - - - Returns the array of unsigned bytes from which this stream was created. The return value indicates whether the conversion succeeded. - true if the conversion was successful; otherwise, false. - The byte array segment from which this stream was created. - - - Writes a block of bytes to the current stream using data read from a buffer. - The buffer to write data from. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The maximum number of bytes to write. - - is null. - The stream does not support writing. For additional information see .-or- The current position is closer than bytes to the end of the stream, and the capacity cannot be modified. - - subtracted from the buffer length is less than . - - or are negative. - An I/O error occurs. - The current stream instance is closed. - 2 - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current stream at the current position. - The byte to write. - The stream does not support writing. For additional information see .-or- The current position is at the end of the stream, and the capacity cannot be modified. - The current stream is closed. - 2 - - - Writes the entire contents of this memory stream to another stream. - The stream to write this memory stream to. - - is null. - The current or target stream is closed. - 2 - - - Specifies the position in a stream to use for seeking. - 2 - - - Specifies the beginning of a stream. - - - Specifies the current position within a stream. - - - Specifies the end of a stream. - - - Provides a generic view of a sequence of bytes. This is an abstract class.To browse the .NET Framework source code for this type, see the Reference Source. - 2 - - - Initializes a new instance of the class. - - - When overridden in a derived class, gets a value indicating whether the current stream supports reading. - true if the stream supports reading; otherwise, false. - 1 - - - When overridden in a derived class, gets a value indicating whether the current stream supports seeking. - true if the stream supports seeking; otherwise, false. - 1 - - - Gets a value that determines whether the current stream can time out. - A value that determines whether the current stream can time out. - 2 - - - When overridden in a derived class, gets a value indicating whether the current stream supports writing. - true if the stream supports writing; otherwise, false. - 1 - - - Reads the bytes from the current stream and writes them to another stream. - The stream to which the contents of the current stream will be copied. - - is null. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - The stream to which the contents of the current stream will be copied. - The size of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - The current stream does not support reading.-or- does not support writing. - Either the current stream or were closed before the method was called. - An I/O error occurred. - - - Asynchronously reads the bytes from the current stream and writes them to another stream. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - - is null. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token. - A task that represents the asynchronous copy operation. - The stream to which the contents of the current stream will be copied. - The size, in bytes, of the buffer. This value must be greater than zero. The default size is 81920. - The token to monitor for cancellation requests. The default value is . - - is null. - - is negative or zero. - Either the current stream or the destination stream is disposed. - The current stream does not support reading, or the destination stream does not support writing. - - - Releases all resources used by the . - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device. - An I/O error occurs. - 2 - - - Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests. - A task that represents the asynchronous flush operation. - The token to monitor for cancellation requests. The default value is . - The stream has been disposed. - - - When overridden in a derived class, gets the length in bytes of the stream. - A long value representing the length of the stream in bytes. - A class derived from Stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - A Stream with no backing store. - 1 - - - When overridden in a derived class, gets or sets the position within the current stream. - The current position within the stream. - An I/O error occurs. - The stream does not support seeking. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. - An array of bytes. When this method returns, the buffer contains the specified byte array with the values between and ( + - 1) replaced by the bytes read from the current source. - The zero-based byte offset in at which to begin storing the data read from the current stream. - The maximum number of bytes to be read from the current stream. - The sum of and is larger than the buffer length. - - is null. - - or is negative. - An I/O error occurs. - The stream does not support reading. - Methods were called after the stream was closed. - 1 - - - Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - The buffer to write the data into. - The byte offset in at which to begin writing data from the stream. - The maximum number of bytes to read. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support reading. - The stream has been disposed. - The stream is currently in use by a previous read operation. - - - Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. - The unsigned byte cast to an Int32, or -1 if at the end of the stream. - The stream does not support reading. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out. - A value, in miliseconds, that determines how long the stream will attempt to read before timing out. - The method always throws an . - 2 - - - When overridden in a derived class, sets the position within the current stream. - The new position within the current stream. - A byte offset relative to the parameter. - A value of type indicating the reference point used to obtain the new position. - An I/O error occurs. - The stream does not support seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 1 - - - When overridden in a derived class, sets the length of the current stream. - The desired length of the current stream in bytes. - An I/O error occurs. - The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. - Methods were called after the stream was closed. - 2 - - - When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - An array of bytes. This method copies bytes from to the current stream. - The zero-based byte offset in at which to begin copying bytes to the current stream. - The number of bytes to be written to the current stream. - The sum of  and  is greater than the buffer length. - - is null. - - or  is negative. - An I/O error occured, such as the specified file cannot be found. - The stream does not support writing. - - was called after the stream was closed. - 1 - - - Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests. - A task that represents the asynchronous write operation. - The buffer to write data from. - The zero-based byte offset in from which to begin copying bytes to the stream. - The maximum number of bytes to write. - The token to monitor for cancellation requests. The default value is . - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream does not support writing. - The stream has been disposed. - The stream is currently in use by a previous write operation. - - - Writes a byte to the current position in the stream and advances the position within the stream by one byte. - The byte to write to the stream. - An I/O error occurs. - The stream does not support writing, or the stream is already closed. - Methods were called after the stream was closed. - 2 - - - Gets or sets a value, in miliseconds, that determines how long the stream will attempt to write before timing out. - A value, in miliseconds, that determines how long the stream will attempt to write before timing out. - The method always throws an . - 2 - - - Implements a that reads characters from a byte stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream. - The stream to be read. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified byte order mark detection option. - The stream to be read. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding. - The stream to be read. - The character encoding to use. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding and byte order mark detection option. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - - does not support reading. - - or is null. - - - Initializes a new instance of the class for the specified stream, with the specified character encoding, byte order mark detection option, and buffer size. - The stream to be read. - The character encoding to use. - Indicates whether to look for byte order marks at the beginning of the file. - The minimum buffer size. - The stream does not support reading. - - or is null. - - is less than or equal to zero. - - - Initializes a new instance of the class for the specified stream based on the specified character encoding, byte order mark detection option, and buffer size, and optionally leaves the stream open. - The stream to read. - The character encoding to use. - true to look for byte order marks at the beginning of the file; otherwise, false. - The minimum buffer size. - true to leave the stream open after the object is disposed; otherwise, false. - - - Returns the underlying stream. - The underlying stream. - 2 - - - Gets the current character encoding that the current object is using. - The current character encoding used by the current reader. The value can be different after the first call to any method of , since encoding autodetection is not done until the first call to a method. - 2 - - - Clears the internal buffer. - 2 - - - Closes the underlying stream, releases the unmanaged resources used by the , and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets a value that indicates whether the current stream position is at the end of the stream. - true if the current stream position is at the end of the stream; otherwise false. - The underlying stream has been disposed. - 1 - - - A object around an empty stream. - 1 - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if there are no characters to be read or if the stream does not support seeking. - An I/O error occurs. - 1 - - - Reads the next character from the input stream and advances the character position by one character. - The next character from the input stream represented as an object, or -1 if no more characters are available. - An I/O error occurs. - 1 - - - Reads a specified maximum of characters from the current stream into a buffer, beginning at the specified index. - The number of characters that have been read, or 0 if at the end of the stream and no data was read. The number will be less than or equal to the parameter, depending on whether the data is available within the stream. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The index of at which to begin writing. - The maximum number of characters to read. - The buffer length minus is less than . - - is null. - - or is negative. - An I/O error occurs, such as the stream is closed. - 1 - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current stream and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, contains the specified character array with the values between and () replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurred. - - - Reads a specified maximum number of characters from the current stream asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the stream has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the stream is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current stream and returns the data as a string. - The next line from the input stream, or null if the end of the input stream is reached. - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads a line of characters asynchronously from the current stream and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the stream, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the stream. - The rest of the stream as a string, from the current position to the end. If the current position is at the end of the stream, returns an empty string (""). - There is insufficient memory to allocate a buffer for the returned string. - An I/O error occurs. - 1 - - - Reads all characters from the current position to the end of the stream asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the stream. - The number of characters is larger than . - The stream has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing characters to a stream in a particular encoding.To browse the .NET Framework source code for this type, see the Reference Source. - 1 - - - Initializes a new instance of the class for the specified stream by using UTF-8 encoding and the default buffer size. - The stream to write to. - - is not writable. - - is null. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and the default buffer size. - The stream to write to. - The character encoding to use. - - or is null. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - - or is null. - - is negative. - - is not writable. - - - Initializes a new instance of the class for the specified stream by using the specified encoding and buffer size, and optionally leaves the stream open. - The stream to write to. - The character encoding to use. - The buffer size, in bytes. - true to leave the stream open after the object is disposed; otherwise, false. - - or is null. - - is negative. - - is not writable. - - - Gets or sets a value indicating whether the will flush its buffer to the underlying stream after every call to . - true to force to flush its buffer; otherwise, false. - 1 - - - Gets the underlying stream that interfaces with a backing store. - The stream this StreamWriter is writing to. - 2 - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - The current encoding does not support displaying half of a Unicode surrogate pair. - - - Gets the in which the output is written. - The specified in the constructor for the current instance, or if an encoding was not specified. - 2 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. - The current writer is closed. - An I/O error has occurred. - The current encoding does not support displaying half of a Unicode surrogate pair. - 1 - - - Clears all buffers for this stream asynchronously and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The stream has been disposed. - - - Provides a StreamWriter with no backing store that can be written to, but not read from. - 1 - - - Writes a character to the stream. - The character to write to the stream. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a character array to the stream. - A character array containing the data to write. If is null, nothing is written. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a subarray of characters to the stream. - A character array that contains the data to write. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The buffer length minus is less than . - - or is negative. - An I/O error occurs. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - 1 - - - Writes a string to the stream. - The string to write to the stream. If is null, nothing is written. - - is true or the buffer is full, and current writer is closed. - - is true or the buffer is full, and the contents of the buffer cannot be written to the underlying fixed size stream because the is at the end the stream. - An I/O error occurs. - 1 - - - Writes a character to the stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the stream asynchronously. - A task that represents the asynchronous write operation. - A character array that contains the data to write. - The character position in the buffer at which to begin reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string to the stream asynchronously. - A task that represents the asynchronous write operation. - The string to write to the stream. If is null, nothing is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character to write to the stream. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The stream writer is disposed. - The stream writer is currently in use by a previous write operation. - - - Implements a that reads from a string. - 2 - - - Initializes a new instance of the class that reads from the specified string. - The string to which the should be initialized. - The parameter is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Returns the next available character but does not consume it. - An integer representing the next character to be read, or -1 if no more characters are available or the stream does not support seeking. - The current reader is closed. - 2 - - - Reads the next character from the input string and advances the character position by one character. - The next character from the underlying string, or -1 if no more characters are available. - The current reader is closed. - 2 - - - Reads a block of characters from the input string and advances the character position by . - The total number of characters read into the buffer. This can be less than the number of characters requested if that many characters are not currently available, or zero if the end of the underlying string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The starting index in the buffer. - The number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The current reader is closed. - 2 - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current string asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the string has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the string is reached before the specified number of characters is written into the buffer, the method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the current string and returns the data as a string. - The next line from the current string, or null if the end of the string is reached. - The current reader is closed. - There is insufficient memory to allocate a buffer for the returned string. - 2 - - - Reads a line of characters asynchronously from the current string and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the string reader, or is null if all the characters have been read. - The number of characters in the next line is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the string and returns them as a single string. - The content from the current position to the end of the underlying string. - There is insufficient memory to allocate a buffer for the returned string. - The current reader is closed. - 2 - - - Reads all characters from the current position to the end of the string asynchronously and returns them as a single string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the string. - The number of characters is larger than . - The string reader has been disposed. - The reader is currently in use by a previous read operation. - - - Implements a for writing information to a string. The information is stored in an underlying . - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format control. - An object that controls formatting. - - - Initializes a new instance of the class that writes to the specified . - The StringBuilder to write to. - - is null. - - - Initializes a new instance of the class that writes to the specified and has the specified format provider. - The StringBuilder to write to. - An object that controls formatting. - - is null. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Gets the in which the output is written. - The Encoding in which the output is written. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - - - Returns the underlying . - The underlying StringBuilder. - 2 - - - Returns a string containing the characters written to the current StringWriter so far. - The string containing the characters written to the current StringWriter. - 2 - - - Writes a character to the string. - The character to write. - The writer is closed. - 2 - - - Writes a subarray of characters to the string. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - - or is negative. - ( + )> . Length. - The writer is closed. - 2 - - - Writes a string to the current string. - The string to write. - The writer is closed. - 2 - - - Writes a character to the string asynchronously. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the string asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string to the current string asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character to write to the string. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the string. - A task that represents the asynchronous write operation. - The character array to write data from. - The position in the buffer at which to start reading data. - The maximum number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the current string. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The string writer is disposed. - The string writer is currently in use by a previous write operation. - - - Represents a reader that can read a sequential series of characters. - 2 - - - Initializes a new instance of the class. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - Provides a TextReader with no data to read from. - 1 - - - Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the reader. - An integer representing the next character to be read, or -1 if no more characters are available or the reader does not support seeking. - The is closed. - An I/O error occurs. - 1 - - - Reads the next character from the text reader and advances the character position by one character. - The next character from the text reader, or -1 if no more characters are available. The default implementation returns -1. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether the data is available within the reader. This method returns 0 (zero) if it is called when no more characters are left to read. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the reader is reached before the specified number of characters is read into the buffer, the method returns. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a specified maximum number of characters from the current text reader and writes the data to a buffer, beginning at the specified index. - The number of characters that have been read. The number will be less than or equal to , depending on whether all input characters have been read. - When this method returns, this parameter contains the specified character array with the values between and ( + -1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. - - is null. - The buffer length minus is less than . - - or is negative. - The is closed. - An I/O error occurs. - 2 - - - Reads a specified maximum number of characters from the current text reader asynchronously and writes the data to a buffer, beginning at the specified index. - A task that represents the asynchronous read operation. The value of the parameter contains the total number of bytes read into the buffer. The result value can be less than the number of bytes requested if the number of bytes currently available is less than the requested number, or it can be 0 (zero) if the end of the text has been reached. - When this method returns, contains the specified character array with the values between and ( + - 1) replaced by the characters read from the current source. - The position in at which to begin writing. - The maximum number of characters to read. If the end of the text is reached before the specified number of characters is read into the buffer, the current method returns. - - is null. - - or is negative. - The sum of and is larger than the buffer length. - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads a line of characters from the text reader and returns the data as a string. - The next line from the reader, or null if all characters have been read. - An I/O error occurs. - There is insufficient memory to allocate a buffer for the returned string. - The is closed. - The number of characters in the next line is larger than - 1 - - - Reads a line of characters asynchronously and returns the data as a string. - A task that represents the asynchronous read operation. The value of the parameter contains the next line from the text reader, or is null if all of the characters have been read. - The number of characters in the next line is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Reads all characters from the current position to the end of the text reader and returns them as one string. - A string that contains all characters from the current position to the end of the text reader. - An I/O error occurs. - The is closed. - There is insufficient memory to allocate a buffer for the returned string. - The number of characters in the next line is larger than - 1 - - - Reads all characters from the current position to the end of the text reader asynchronously and returns them as one string. - A task that represents the asynchronous read operation. The value of the parameter contains a string with the characters from the current position to the end of the text reader. - The number of characters is larger than . - The text reader has been disposed. - The reader is currently in use by a previous read operation. - - - Represents a writer that can write a sequential series of characters. This class is abstract. - 2 - - - Initializes a new instance of the class. - - - Initializes a new instance of the class with the specified format provider. - An object that controls formatting. - - - Stores the newline characters used for this TextWriter. - - - Releases all resources used by the object. - - - Releases the unmanaged resources used by the and optionally releases the managed resources. - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - When overridden in a derived class, returns the character encoding in which the output is written. - The character encoding in which the output is written. - 1 - - - Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - 1 - - - Asynchronously clears all buffers for the current writer and causes any buffered data to be written to the underlying device. - A task that represents the asynchronous flush operation. - The text writer is disposed. - The writer is currently in use by a previous write operation. - - - Gets an object that controls formatting. - An object for a specific culture, or the formatting of the current culture if no other culture is specified. - 2 - - - Gets or sets the line terminator string used by the current TextWriter. - The line terminator string for the current TextWriter. - 2 - - - Provides a TextWriter with no backing store that can be written to, but not read from. - 1 - - - Writes the text representation of a Boolean value to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a character array to the text string or stream. - The character array to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters to the text string or stream. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte floating-point value to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object to the text string or stream by calling the ToString method on that object. - The object to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string to the text string or stream. - The string to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero) or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes a formatted string to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - - or is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character array to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If is null, nothing is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string to the text string or stream asynchronously. - A task that represents the asynchronous write operation. - The string to write. If is null, nothing is written to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a line terminator to the text string or stream. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a Boolean value followed by a line terminator to the text string or stream. - The Boolean value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a character followed by a line terminator to the text string or stream. - The character to write to the text stream. - The is closed. - An I/O error occurs. - 1 - - - Writes an array of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The is closed. - An I/O error occurs. - 1 - - - Writes a subarray of characters followed by a line terminator to the text string or stream. - The character array from which data is read. - The character position in at which to start reading data. - The maximum number of characters to write. - The buffer length minus is less than . - The parameter is null. - - or is negative. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a decimal value followed by a line terminator to the text string or stream. - The decimal value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 8-byte floating-point value followed by a line terminator to the text string or stream. - The 8-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte signed integer followed by a line terminator to the text string or stream. - The 4-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte signed integer followed by a line terminator to the text string or stream. - The 8-byte signed integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an object by calling the ToString method on that object, followed by a line terminator to the text string or stream. - The object to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of a 4-byte floating-point value followed by a line terminator to the text string or stream. - The 4-byte floating-point value to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a string followed by a line terminator to the text string or stream. - The string to write. If is null, only the line terminator is written. - The is closed. - An I/O error occurs. - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is one). - 1 - - - Writes a formatted string and a new line to the text string or stream, using the same semantics as the method. - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is two). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - The first object to format and write. - The second object to format and write. - The third object to format and write. - - is null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the number of objects to be formatted (which, for this method overload, is three). - 1 - - - Writes out a formatted string and a new line, using the same semantics as . - A composite format string (see Remarks). - An object array that contains zero or more objects to format and write. - A string or object is passed in as null. - The is closed. - An I/O error occurs. - - is not a valid composite format string.-or- The index of a format item is less than 0 (zero), or greater than or equal to the length of the array. - 1 - - - Writes the text representation of a 4-byte unsigned integer followed by a line terminator to the text string or stream. - The 4-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes the text representation of an 8-byte unsigned integer followed by a line terminator to the text string or stream. - The 8-byte unsigned integer to write. - The is closed. - An I/O error occurs. - 1 - - - Writes a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a character followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character to write to the text stream. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes an array of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write to the text stream. If the character array is null, only the line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a subarray of characters followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The character array to write data from. - The character position in the buffer at which to start retrieving data. - The number of characters to write. - - is null. - The plus is greater than the buffer length. - - or is negative. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - Writes a string followed by a line terminator asynchronously to the text string or stream. - A task that represents the asynchronous write operation. - The string to write. If the value is null, only a line terminator is written. - The text writer is disposed. - The text writer is currently in use by a previous write operation. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml deleted file mode 100644 index 07b2661f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/de/System.IO.xml +++ /dev/null @@ -1,2151 +0,0 @@ - - - - System.IO - - - - Liest primitive Datentypen als Binärwerte in einer spezifischen Codierung. - 2 - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung unter Verwendung von UTF-8. - Der Eingabestream. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - - Initialisiert eine neue Instanz der auf dem bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Eingabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Lesevorgänge, ist null oder er wurde bereits geschlossen. - - oder ist null. - - - Gewährt Zugriff auf den zugrunde liegenden Stream von . - Der BinaryReader zugeordnete, zugrunde liegende Stream. - 2 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Füllt den internen Puffer mit der angegebenen Anzahl von Bytes, die aus dem Stream gelesen wurden. - Die Anzahl der zu lesenden Bytes. - Das Ende des Streams ist erreicht, bevor gelesen werden konnte. - E/A-Fehler. - Die angeforderten überschreiten die interne Puffergröße. - - - Gibt das nächste verfügbare Zeichen zurück, ohne die Byte- oder Zeichenposition zu erhöhen. - Das nächste verfügbare Zeichen oder -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - Das aktuelle Zeichen kann nicht mit dem für den Stream ausgewählten in den internen Zeichenpuffer decodiert werden. - 2 - - - Liest Zeichen aus dem zugrunde liegenden Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Das nächste Zeichen aus dem Eingabestream bzw. -1, wenn derzeit keine Zeichen verfügbar sind. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Liest die angegebene Anzahl von Bytes beginnend bei einem angegebenen Punkt im Bytearray aus dem Stream. - Die Anzahl von Bytes, die in gelesen wurden.Diese kann kleiner sein als die Anzahl der angeforderten Bytes, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Bytes. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Zeichen beginnend bei einem angegebenen Punkt im Zeichenarray aus dem Stream. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn gegenwärtig keine entsprechende Anzahl von Bytes verfügbar ist, oder null, wenn das Ende des Streams erreicht ist. - Der Puffer, in den Daten gelesen werden sollen. - Der Anfangspunkt für das Lesen in den Puffer. - Die Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - oder - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - - ist null. - - oder ist negativ. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 32-Bit-Ganzzahl in komprimiertem Format. - Eine 32-Bit-Ganzzahl in komprimiertem Format. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Der Datenstrom ist beschädigt. - - - Liest einen Boolean-Wert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - true, wenn das Byte ungleich 0 (null) ist, andernfalls false. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest das nächste Byte aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 1 Byte. - Das nächste aus dem aktuellen Stream gelesene Byte. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest die angegebene Anzahl von Bytes aus dem aktuellen Stream in ein Bytearray und erhöht die aktuelle Position um diese Anzahl von Bytes. - Ein Bytearray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Bytes, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Bytes.Dieser Wert muss 0 oder eine nicht negative Zahl sein; andernfalls tritt eine Ausnahme auf. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - E/A-Fehler. - Der Stream ist geschlossen. - - ist negativ. - 2 - - - Liest das nächste Zeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein aus dem aktuellen Stream gelesenes Zeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - Ein Ersatzzeichenzeichen wurde gelesen. - 2 - - - Liest die angegebene Anzahl von Zeichen aus dem aktuellen Stream, gibt die Daten in einem Zeichenarray zurück und erhöht die aktuelle Position in Abhängigkeit von der verwendeten Encoding und dem aus dem Stream gelesenen Zeichen. - Ein Zeichenarray mit Daten aus dem zugrunde liegenden Stream.Dies kann kleiner sein als die Anzahl der angeforderten Zeichen, wenn das Ende des Streams erreicht ist. - Die Anzahl der zu lesenden Zeichen. - Die Anzahl der zu lesenden decodierten Zeichen ist größer als .Dies kann geschehen, wenn ein Unicode-Decoder Fallbackzeichen oder ein Ersatzzeichenpaar zurückgibt. - Der Stream ist geschlossen. - E/A-Fehler. - - ist negativ. - 2 - - - Liest einen Dezimalwert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 16 Bytes. - Ein aus dem aktuellen Stream gelesener Dezimalwert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 8-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Ein aus dem aktuellen Stream gelesener 8-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus dem aktuellen Stream gelesene 2-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Eine aus dem aktuellen Stream gelesene 4-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 8 Bytes. - Eine aus dem aktuellen Stream gelesene 8-Byte-Ganzzahl mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest ein Byte mit Vorzeichen aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Ein aus dem aktuellen Stream gelesenes Byte mit Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest einen 4-Byte-Gleitkommawert aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 4 Bytes. - Ein aus dem aktuellen Stream gelesener 4-Byte-Gleitkommawert. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine Zeichenfolge aus dem aktuellen Stream.Die Zeichenfolge weist ein Präfix mit der Länge auf, die als Ganzzahl mit jeweils 7 Bits codiert ist. - Die gelesene Zeichenfolge. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 2-Byte-Ganzzahl ohne Vorzeichen mithilfe einer Little-Endian-Codierung aus dem aktuellen Stream und erhöht die aktuelle Position im Stream um 2 Bytes. - Eine aus diesem Stream gelesene 2-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 4-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 4 Bytes. - Eine aus diesem Stream gelesene 4-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - E/A-Fehler. - 2 - - - Liest eine 8-Byte-Ganzzahl ohne Vorzeichen aus dem aktuellen Stream und erhöht die Position des Streams um 8 Bytes. - Eine aus diesem Stream gelesene 8-Byte-Ganzzahl ohne Vorzeichen. - Das Ende des Streams ist erreicht. - E/A-Fehler. - Der Stream ist geschlossen. - 2 - - - Schreibt primitive Typen binär in einen Stream und unterstützt das Schreiben von Zeichenfolgen in einer bestimmten Codierung. - 2 - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in einen Stream. - - - Initialisiert eine neue Instanz der auf dem spezifizierten Stream basierenden -Klasse unter Verwendung von UTF-8-Verschlüsselung. - Der Ausgabestream. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - ist null. - - - Initialisiert eine neue Instanz der auf den bereitgestellten Stream basierenden -Klasse mit einer spezifischen Stream- und Zeichencodierung. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse auf Grundlage des angegebenen Streams und der Zeichencodierung und lässt den Stream optional geöffnet. - Der Ausgabestream. - Die zu verwendende Zeichencodierung. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - - oder ist null. - - - Ruft den zugrunde liegenden Stream von ab. - Der BinaryWriter zugeordnete, zugrunde liegende Stream. - 1 - - - Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Gibt eine -Klasse ohne Sicherungsspeicher an. - 1 - - - Enthält den zugrunde liegenden Stream. - - - Legt die Position im aktuellen Stream fest. - Die Position im aktuellen Stream. - Ein Byteoffset im Verhältnis zu . - Ein Feld von , das den Bezugspunkt angibt, von dem aus die neue Position ermittelt werden soll. - Der Dateizeiger wurde an eine ungültige Position verschoben. - Der -Wert ist ungültig. - 1 - - - Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt. - Der zu schreibende Boolean-Wert (0 (null) oder 1). - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Bytearray in den zugrunde liegenden Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - E/A-Fehler. - Der Stream ist geschlossen. - - ist null. - 1 - - - Schreibt einen Bereich eines Bytearrays in den aktuellen Stream. - Ein Bytearray, das die zu schreibenden Daten enthält. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Bytes. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen). - E/A-Fehler. - Der Stream ist geschlossen. - - ist ein einzelnes Ersatzzeichen. - 1 - - - Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - - ist null. - Der Stream ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen. - Ein Zeichenarray mit den zu schreibenden Daten. - Der Anfangspunkt im , an dem mit dem Schreiben begonnen wird. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes. - Der zu schreibende Dezimalwert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Der zu schreibende 8-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das zu schreibende Byte mit Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Der zu schreibende 4-Byte-Gleitkommawert. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen. - Der zu schreibende Wert. - E/A-Fehler. - - ist null. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes. - Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - E/A-Fehler. - Der Stream ist geschlossen. - 1 - - - Schreibt eine 32-Bit-Ganzzahl in einem komprimierten Format. - Die zu schreibende 32-Bit-Ganzzahl. - Das Ende des Streams ist erreicht. - Der Stream ist geschlossen. - Der Stream ist geschlossen. - - - Die Ausnahme, die ausgelöst wird, wenn hinter dem Ende eines Streams ein Leseversuch erfolgt. - 2 - - - Initialisiert eine neue Instanz der -Klasse, bei der die Meldungszeichenfolge auf eine vom System gelieferte Meldung und HRESULT auf COR_E_ENDOFSTREAM festgelegt ist. - - - Initialisiert eine neue Instanz der -Klasse, bei der die Nachrichtenzeichenfolge auf und HRESULT auf COR_E_ENDOFSTREAM festgelegt wurde. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. - Eine Zeichenfolge, die den Fehler beschreibt.Der Inhalt der soll in verständlicher Sprache gehalten sein.Der Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Die Ausnahme, die ausgelöst wird, wenn ein Datenstream ein ungültiges Format hat. - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - - - Initialisiert eine neue Instanz der -Klasse mit einem Verweis auf die innere Ausnahme, die die Ausnahme ausgelöst hat. - Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. - Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. - - - Erstellt einen Stream, der den Arbeitsspeicher als Sicherungsspeicher verwendet.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit 0 (null) initialisiert wurde. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem der aktuelle Stream erstellt werden soll. - - ist null. - - - Initialisiert anhand des angegebenen Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wird. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - - Initialisiert anhand des angegebenen Bereichs (Indexes) eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - - ist null. - - oder ist kleiner als 0. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert anhand des angegebenen Bereichs eines Bytearrays eine neue Instanz der -Klasse, deren Größe nicht geändert werden kann, wobei die -Eigenschaft wie angegeben festgelegt wurde. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , bei dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse auf der Grundlage des angegebenen Bereichs eines Bytearrays, wobei die -Eigenschaft und die Möglichkeit zum Aufruf von wie angegeben festgelegt werden. - Das Array vorzeichenloser Bytes, aus dem dieser Stream erstellt werden soll. - Der Index in , an dem der Stream beginnt. - Die Länge des Streams in Bytes. - Die Einstellung der -Eigenschaft, mit der bestimmt wird, ob der Stream Schreibvorgänge unterstützt. - true, um zu aktivieren, wodurch das Array vorzeichenloser Bytes zurückgegeben wird, aus dem der Stream erstellt wurde, andernfalls false. - - ist null. - - oder ist negativ. - Die Länge des Puffers minus ist kleiner als . - - - Initialisiert eine neue Instanz der -Klasse mit einer erweiterbaren Kapazität, die mit dem angegebenen Wert initialisiert wird. - Die Anfangsgröße des internen Arrays in Bytes. - - ist negativ. - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream geöffnet ist. - 2 - - - Ruft einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 2 - - - Ruft die Anzahl der für diesen Stream reservierten Bytes ab oder legt diese fest. - Die Länge des Bereichs, der für den Stream im Puffer verwendet werden kann. - Es wurde eine Kapazität festgelegt, die negativ oder kleiner als die derzeitige Länge des Streams ist. - Der aktuelle Stream ist geschlossen. - set wird für einen Stream aufgerufen, dessen Kapazität nicht geändert werden kann. - 2 - - - Liest alle Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein. - Das Token zum überwachen von Abbruchanforderungen . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt die von der -Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Überschreibt die -Methode, sodass keine Aktion durchgeführt wird. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen . - Der Stream wurde freigegeben. - - - Ruft die Länge des Streams in Bytes ab. - Die Länge des Streams in Bytes. - Der Stream ist geschlossen. - 2 - - - Ruft die aktuelle Position im Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - Die Position ist auf einen negativen Wert oder einen größeren Wert als festgelegt. - Der Stream ist geschlossen. - 2 - - - Liest einen Byteblock aus dem aktuellen Stream und schreibt die Daten in einen Puffer. - Die Gesamtanzahl der in den Puffer geschriebenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder null, wenn das Ende des Streams erreicht ist, bevor mindestens ein Byte gelesen wurde. - Enthält nach dem Beenden dieser Methode das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus dem aktuellen Stream gelesene Zeichen ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die Daten aus dem aktuellen Stream gespeichert werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - - subtrahiert von der Pufferlänge ist kleiner als . - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem aktuellen Stream. - Das Byte, das in umgewandelt wurde, oder -1, wenn das Ende des Streams erreicht wurde. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Position im aktuellen Stream auf den angegebenen Wert fest. - Die neue Position im Stream, die durch Kombinieren des anfänglichen Verweispunktes und des Offsets berechnet wird. - Die neue Position innerhalb des Streams.Diese ist relativ zum -Parameter und kann positiv oder negativ sein. - Ein Wert vom Typ , der den Bezugspunkt für die Suche darstellt. - Es wurde versucht, eine Suche vor dem Anfang des Streams auszuführen. - - ist größer als . - Ein ist ungültig. - oder - hat einen arithmetischen Überlauf verursacht. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Legt die Länge des aktuellen Streams auf den angegebenen Wert fest. - Der Wert, auf den die Länge festgelegt werden soll. - Die Größe des aktuellen Streams kann nicht geändert werden, und übersteigt die aktuelle Kapazität.- oder - Der aktuelle Stream unterstützt keine Schreibvorgänge. - - ist negativ oder größer als die maximale Länge von , wobei die maximale Länge ( - Ursprung) ist, und der Ursprung der Index des zugrunde liegenden Puffers ist, an dem der Stream beginnt. - 2 - - - Schreibt den Inhalt des Streams in ein Bytearray, unabhängig von der -Eigenschaft. - Ein neues Bytearray. - 2 - - - Gibt das Array vorzeichenloser Bytes zurück, aus dem dieser Stream erstellt wurde.Der Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde. - true, wenn die Konvertierung erfolgreich war, andernfalls false. - Das Bytearraysegment, aus dem der Stream erstellt wurde. - - - Schreibt einen Byteblock mit den aus einem Puffer gelesenen Daten in den aktuellen Stream. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Der Abstand der aktuellen Position zum Ende des Streams beträgt weniger als Bytes, und die Kapazität kann nicht geändert werden. - - subtrahiert von der Pufferlänge ist kleiner als . - - oder ist negativ. - E/A-Fehler. - Der aktuelle Instanz des Streams ist geschlossen. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuelle Position im aktuellen Stream. - Das zu schreibende Byte. - Der Stream unterstützt das Schreiben nicht.Weitere Informationen finden Sie unter .- oder - Die aktuelle Position befindet sich am Ende des Streams, und die Kapazität kann nicht geändert werden. - Der aktuelle Stream ist geschlossen. - 2 - - - Schreibt den gesamten Inhalt dieses Arbeitsspeicherstreams in einen anderen Stream. - Der Stream, in den dieser Arbeitsspeicherstream geschrieben werden soll. - - ist null. - Der aktuelle Stream oder der Zielstream ist geschlossen. - 2 - - - Gibt die Position in einem Stream an, der für die Suche verwendet werden soll. - 2 - - - Gibt den Anfang eines Streams an. - - - Gibt die aktuelle Position innerhalb eines Streams an. - - - Gibt das Ende eines Streams an. - - - Stellt eine allgemeine Ansicht einer Folge von Bytes bereit.Dies ist eine abstrakte Klasse.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Lesevorgänge unterstützt. - true, wenn der Stream Lesevorgänge unterstützt, andernfalls false. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Suchvorgänge unterstützt. - true, wenn der Stream Suchvorgänge unterstützt, andernfalls false. - 1 - - - Ruft einen Wert ab, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - Ein Wert, der bestimmt, ob für den aktuellen Stream ein Timeout möglich ist. - 2 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse einen Wert ab, der angibt, ob der aktuelle Stream Schreibvorgänge unterstützt. - true, wenn der Stream Schreibvorgänge unterstützt, andernfalls false. - 1 - - - Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Puffers.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Der aktuelle Stream unterstützt keine Lesevorgänge.- oder - unterstützt das Schreiben nicht. - Entweder der aktuelle Stream oder wurde geschlossen, bevor die -Methode aufgerufen wurde. - Ein E/A-Fehler ist aufgetreten. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - - ist null. - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. - Eine Aufgabe, die den asynchronen Kopiervorgang darstellt. - Der Stream, in den der Inhalt des aktuellen Stream kopiert wird. - Die Größe des Cookies in Bytes.Dieser Wert muss größer als 0 sein.Die Standardgröße ist 81920. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - ist negativ oder 0 (null). - Entweder der aktuelle Stream oder der Zielstream wird freigegeben. - Der aktuelle Stream unterstützt kein Lesen oder Zielstream unterstützt keine Schreibvorgänge. - - - Gibt alle vom verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Löscht beim Überschreiben in einer abgeleiteten Klasse alle Puffer für diesen Stream und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - E/A-Fehler. - 2 - - - Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Löscht alle Puffer für diesen Stream asynchron, veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - Der Stream wurde freigegeben. - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Länge des Streams in Bytes ab. - Ein Long-Wert, der die Länge des Streams in Bytes darstellt. - Eine aus Stream abgeleitete Klasse unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Ein Stream ohne Sicherungsspeicher. - 1 - - - Ruft beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream ab oder legt diese fest. - Die aktuelle Position innerhalb des Streams. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes. - Die Gesamtanzahl der in den Puffer gelesenen Bytes.Dies kann weniger als die Anzahl der angeforderten Bytes sein, wenn diese Anzahl an Bytes derzeit nicht verfügbar ist, oder 0, wenn das Ende des Streams erreicht ist. - Ein Bytearray.Nach dem Beenden dieser Methode enthält der Puffer das angegebene Bytearray mit den Werten zwischen und ( + - 1), die durch aus der aktuellen Quelle gelesene Bytes ersetzt wurden. - Der nullbasierte Byteoffset im , ab dem die aus dem aktuellen Stream gelesenen Daten gespeichert werden. - Die maximale Anzahl an Bytes, die aus dem aktuellen Stream gelesen werden sollen. - Die Summe aus und ist größer als die Pufferlänge. - - ist null. - - oder ist negativ. - E/A-Fehler. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest eine Folge von Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Der Puffer, in den die Daten geschrieben werden sollen. - Der Byteoffset im , ab dem Daten aus dem Stream geschrieben werden. - Die maximale Anzahl der zu lesenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Lesevorgänge werden vom Stream nicht unterstützt. - Der Stream wurde freigegeben. - Der Stream wird gerade durch einen früheren Lesevorgang. - - - Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist. - Das Byte ohne Vorzeichen, umgewandelt in Int32, oder -1, wenn das Ende des Streams erreicht ist. - Lesevorgänge werden vom Stream nicht unterstützt. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Lesevorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Position im aktuellen Stream fest. - Die neue Position innerhalb des aktuellen Streams. - Ein Byteoffset relativ zum -Parameter. - Ein Wert vom Typ , der den Bezugspunkt angibt, von dem aus die neue Position ermittelt wird. - E/A-Fehler. - Der Stream unterstützt keine Suchvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Legt beim Überschreiben in einer abgeleiteten Klasse die Länge des aktuellen Streams fest. - Die gewünschte Länge des aktuellen Streams in Bytes. - E/A-Fehler. - Der Stream unterstützt nicht sowohl Lese- als auch Schreibvorgänge. Dies ist beispielsweise der Fall, wenn der Stream aus einer Pipe- oder Konsolenausgabe erstellt wird. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes. - Ein Bytearray.Diese Methode kopiert Bytes aus dem in den aktuellen Stream. - Der nullbasierte Byteoffset im , ab dem Bytes in den aktuellen Stream kopiert werden. - Die Anzahl an Bytes, die in den aktuellen Stream geschrieben werden sollen. - Die Summe der  und  ist größer als die Länge des Puffers. - - ist null. - - oder  ist negativ. - E/a-Fehler, wie z. B. die angegebene Datei nicht gefunden werden kann. - Der Stream unterstützt das Schreiben nicht. - - wurde aufgerufen, nachdem der Stream geschlossen wurde. - 1 - - - Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Puffer, aus dem Daten geschrieben werden sollen. - Der nullbasierte Byteoffset im , ab dem Bytes in den Stream kopiert werden. - Die maximale Anzahl der zu schreibenden Bytes. - Das Token zum überwachen von Abbruchanforderungen .Der Standardwert ist . - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream unterstützt das Schreiben nicht. - Der Stream wurde freigegeben. - Der Stream wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte. - Das Byte, das in den Stream geschrieben werden soll. - E/A-Fehler. - Der Stream unterstützt keine Schreibvorgänge, oder er wurde bereits geschlossen. - Es wurden Methoden aufgerufen, nachdem der Stream geschlossen wurde. - 2 - - - Ruft einen Wert in Millisekunden ab, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt, oder legt diesen fest. - Ein Wert in Millisekunden, der bestimmt, wie lange der Stream versucht, Schreibvorgänge durchzuführen, bevor ein Timeout auftritt. - Die -Methode löst immer eine aus. - 2 - - - Implementiert einen , der Zeichen aus einem Bytestream in einer bestimmten Codierung liest.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream. - Der zu lesende Stream. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream und mit der angegebenen Zeichencodierung. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung und Option zur Erkennung der Bytereihenfolgemarken. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - - unterstützt keine Lesevorgänge. - - oder ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream mit der angegebenen Zeichencodierung, Option zur Erkennung der Bytereihenfolgemarken und Puffergröße. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - Gibt an, ob am Anfang der Datei nach Bytereihenfolgemarken gesucht werden soll. - Die Mindestgröße des Puffers. - Lesevorgänge werden vom Stream nicht unterstützt. - - oder ist null. - - ist kleiner oder gleich 0 (null). - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream auf Grundlage der angegebenen Zeichencodierung, der Option zur Erkennung der Bytereihenfolgenmarken, der Puffergröße und lässt optional den Stream geöffnet. - Der zu lesende Stream. - Die zu verwendende Zeichencodierung. - true, um am Anfang der Datei nach Bytereihenfolgemarken zu suchen, andernfalls false. - Die Mindestgröße des Puffers. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - - Gibt den zugrunde liegenden Stream zurück. - Der zugrunde liegende Stream. - 2 - - - Ruft die aktuelle Zeichencodierung ab, die das aktuelle -Objekt verwendet. - Die durch das aktuelle Leseprogramm verwendete aktuelle Zeichencodierung.Der Wert kann sich nach dem ersten Aufruf einer -Methode von ändern, da die automatische Erkennung der Codierung erst nach dem ersten Aufruf einer -Methode erfolgt. - 2 - - - Löscht den internen Puffer. - 2 - - - Schließt den zugrunde liegenden Stream und gibt die vom verwendeten nicht verwalteten Ressourcen sowie optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft einen Wert ab, der angibt, ob sich die aktuelle Streamposition am Ende des Streams befindet. - true, wenn sich die aktuelle Streamposition am Ende des Streams befindet, andernfalls false. - Der zugrunde liegende Stream wurde verworfen. - 1 - - - Ein -Objekt um einen leeren Stream. - 1 - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder -1, wenn keine zu lesenden Zeichen vorhanden sind oder der Stream keine Suchvorgänge unterstützt. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Eingabestream und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Eingabestream wird als -Objekt dargestellt, oder -1, wenn keine weiteren Zeichen verfügbar sind. - E/A-Fehler. - 1 - - - Liest vom aktuellen Stream ein angegebenes Maximum von Zeichen in einen Puffer ein und beginnt dabei am angegebenen Index. - Die Anzahl der gelesenen Zeichen, bzw. 0 (null), wenn das Ende des Streams erreicht ist und keine Daten gelesen wurden.Die Anzahl ist gleich dem -Parameter oder kleiner, abhängig davon, ob die Daten im Stream verfügbar sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Index von , bei dem mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - - ist null. - - oder ist negativ. - Es ist ein E/A-Fehler aufgetreten, beispielsweise das Schließen eines Streams. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und (), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - Ein E/A-Fehler ist aufgetreten. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus dem aktuellen Stream und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Datenstromende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Streams erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Eingabestreams bzw. null, wenn das Ende des Eingabestreams erreicht ist. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest eine Zeile von Zeichen asynchron aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Stream oder ist null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams. - Der Rest des Streams als Zeichenfolge, von der aktuellen Position bis zum Ende.Wenn die aktuelle Position am Ende des Streams ist, wird eine leere Zeichenfolge ("") zurückgegeben. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - E/A-Fehler. - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Streams. - Die Anzahl der Zeichen ist niedriger als . - Der Stream wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Zeichen in einen Stream in einer bestimmten Codierung.Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, rufen Sie die Verweisquelle auf. - 1 - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der UTF-8-Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - - ist schreibgeschützt. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und der Standardpuffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - - oder ist null. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Initialisiert eine neue Instanz der -Klasse für den angegebenen Stream unter Verwendung der angegebenen Codierung und Puffergröße und lässt optional den Stream geöffnet. - Der Stream, in den geschrieben werden soll. - Die zu verwendende Zeichencodierung. - Die Puffergröße in Byte. - true, um den Datenstrom geöffnet zu lassen, nach dem das -Objekt freigegeben wurde; andernfalls false. - - oder ist null. - - ist negativ. - - ist schreibgeschützt. - - - Ruft einen Wert ab, der angibt, ob der nach jedem Aufruf von den Puffer in den zugrunde liegenden Stream wegschreibt, oder legt diesen Wert fest. - true, um zum Entleeren des Puffers zu zwingen, andernfalls false. - 1 - - - Ruft den zugrunde liegenden Stream ab, der eine Schnittstelle zu einem Sicherungsspeicher bildet. - Der Stream, in den dieser StreamWriter schreibt. - 2 - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die im Konstruktor für die aktuelle Instanz angegebene oder , sofern keine Codierung angegeben wurde. - 2 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an den zugrunde liegenden Stream. - Der aktuelle Writer wird geschlossen. - Ein E/A-Fehler ist aufgetreten. - Die aktuelle Codierung unterstützt das Anzeigen einer Hälfte eines Unicode-Ersatzzeichenpaars nicht. - 1 - - - Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Stream wurde freigegeben. - - - Stellt einen StreamWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt ein Zeichen in den Stream. - Das in den Stream zu schreibende Zeichen. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Zeichenarray in den Stream. - Ein Zeichenarray mit den zu schreibenden Daten.Wenn den Wert null ist, wird nichts geschrieben. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt ein Teilarray von Zeichen in den Stream. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - E/A-Fehler. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - 1 - - - Schreibt eine Zeichenfolge in den Stream. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert NULL hat, wird nichts geschrieben. - - ist true, oder der -Puffer ist voll, und der aktuelle Writer ist geschlossen. - - ist true, oder der -Puffer ist voll, und der Inhalt des Puffers kann nicht in den zugrunde liegenden Stream fester Größe geschrieben werden, da der sich am Ende des Streams befindet. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Ein Zeichenarray, das die zu schreibenden Daten enthält. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die Zeichenfolge, die in den Stream geschrieben werden soll.Wenn den Wert null ist, wird nichts geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Stream zu schreibende Zeichen. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Streamwriter wird freigegeben. - Der Streamwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Implementiert einen , der aus einer Zeichenfolge liest. - 2 - - - Initialisiert eine neue Instanz der -Klasse, die aus der angegebenen Zeichenfolge liest. - Die Zeichenfolge, mit der der initialisiert werden soll. - Der -Parameter ist null. - - - Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt das nächste verfügbare Zeichen zurück, ohne es zu verarbeiten. - Eine ganze Zahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Stream keine Suchvorgänge unterstützt. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest das nächste Zeichen aus der Eingabezeichenfolge und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen in der zugrunde liegenden Zeichenfolge oder -1, wenn keine weiteren Zeichen verfügbar sind. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest einen Zeichenblock aus der Eingabezeichenfolge und verschiebt die Zeichenposition um die durch angegebene Anzahl von Zeichen nach vorn. - Die Gesamtanzahl der in den Puffer gelesenen Zeichen.Diese kann kleiner als die Anzahl der angeforderten Zeichen sein, wenn diese Anzahl von Zeichen derzeit nicht verfügbar ist, oder 0, wenn das Ende der zugrunde liegenden Zeichenfolge erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Der Anfangsindex im Puffer. - Die Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen asynchron aus der aktuellen Zeichenkette und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Zeichenfolgenende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende der Zeichenfolge erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer geschrieben wurde, erfolgt die Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile der aktuellen Zeichenfolge oder null, wenn das Ende der Zeichenfolge erreicht ist. - Der aktuelle Reader ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - 2 - - - Liest eine Zeile von Zeichen asynchron aus der aktuellen Zeichenkette und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Zeichenfolgenreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Der Inhalt ab der aktuellen Position bis zum Ende der zugrunde liegenden Zeichenfolge. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der aktuelle Reader ist geschlossen. - 2 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Streams und gibt diese als einzelne Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende der Zeichenfolge. - Die Anzahl der Zeichen ist niedriger als . - Der Zeichenfolgen-Reader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Implementiert einen zum Schreiben von Informationen in eine Zeichenfolge.Die Informationen werden in einem zugrunde liegenden gespeichert. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatierungssteuerelement. - Ein -Objekt zum Steuern der Formatierung. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen . - Der StringBuilder, in den geschrieben werden soll. - - ist null. - - - Initialisiert eine neue Instanz der -Klasse zum Schreiben in den angegebenen und mit dem angegebenen Formatanbieter. - Der StringBuilder, in den geschrieben werden soll. - Ein -Objekt zum Steuern der Formatierung. - - ist null. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Ruft die ab, in der die Ausgabe geschrieben wird. - Die Encoding, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - - - Gibt den zugrunde liegenden zurück. - Der zugrunde liegende StringBuilder. - 2 - - - Gibt eine Zeichenfolge zurück, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - Die Zeichenfolge, die die bisher in den aktuellen StringWriter geschriebenen Zeichen enthält. - 2 - - - Schreibt ein Zeichen in die Zeichenfolge. - Das zu schreibende Zeichen. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Teilarray von Zeichen in die Zeichenfolge. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - - oder ist negativ. - ( + )> .Length. - Der Writer ist geschlossen. - 2 - - - Schreibt eine Zeichenfolge in die aktuelle Zeichenfolge. - Die zu schreibende Zeichenfolge. - Der Writer ist geschlossen. - 2 - - - Schreibt ein Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in die Zeichenfolge zu schreibende Zeichen. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Position im Puffer, an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge gefolgt von einem Zeichen für den Zeilenabschluss asynchron in die aktuelle Zeichenfolge. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Zeichenfolgenwriter wird freigegeben. - Der Zeichenfolgenwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Stellt ein Leseprogramm dar, das eine sequenzielle Serie von Zeichenfolgen lesen kann. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Stellt einen TextReader ohne zu lesende Daten bereit. - 1 - - - Liest das nächste Zeichen, ohne den Zustand des Readers oder der Zeichenquelle zu ändern.Gibt das nächste verfügbare Zeichen zurück, ohne es tatsächlich aus dem Reader zu lesen. - Eine Ganzzahl, die das nächste zu lesende Zeichen darstellt, oder auch -1, wenn keine weiteren Zeichen verfügbar sind oder der Reader keine Suchvorgänge unterstützt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest das nächste Zeichen aus dem Text-Reader und verschiebt die Zeichenposition um ein Zeichen nach vorn. - Das nächste Zeichen im Textreader, bzw. -1, wenn keine weiteren Zeichen verfügbar sind.Die Standardimplementierung gibt -1 zurück. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Reader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , abhängig davon, ob die Daten im Reader verfügbar sind.Diese Methode gibt 0 (null) zurück für den Fall, dass sie aufgerufen wird, wenn keine Zeichen mehr zu lesen sind. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Readers erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die Methodenrückgabe. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Die Anzahl der gelesenen Zeichen.Die Anzahl ist kleiner oder gleich , je nachdem, ob alle Eingabezeichen gelesen wurden. - Dieser Parameter enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + -1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen. - - ist null. - Die Länge des Puffers minus ist kleiner als . - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 2 - - - Liest asynchron eine angegebene Höchstanzahl von Zeichen aus dem aktuellen Textreader und schreibt die Daten in einen Puffer, wobei am angegebenen Index begonnen wird. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die Gesamtzahl der Bytes, die in den Puffer gelesen werden.Der Ergebniswert kann niedriger als die Anzahl der angeforderten Bytes sein, wenn die Anzahl an derzeit verfügbaren Bytes kleiner ist als die angeforderte Anzahl, oder sie kann 0 (null) sein, wenn das Textende erreicht ist. - Enthält nach dem Beenden dieser Methode das angegebene Zeichenarray mit den Werten zwischen und ( + - 1), die durch die aus der aktuellen Quelle gelesenen Zeichen ersetzt wurden. - Die Position in , an der mit dem Schreiben begonnen wird. - Die maximale Anzahl der zu lesenden Zeichen.Wenn das Ende des Texts erreicht ist, bevor die angegebene Anzahl von Zeichen in den Puffer gelesen wurde, erfolgt die aktuelle Methodenrückgabe. - - ist null. - - oder ist negativ. - Die Summe aus und ist größer als die Pufferlänge. - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest eine Zeile von Zeichen aus dem Textleser und gibt die Daten als Zeichenfolge zurück. - Die nächste Zeile des Readers oder null, wenn alle Zeichen gelesen wurden. - E/A-Fehler. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Der ist geschlossen. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest eine Zeile von asynchron Zeichen aus dem aktuellen Stream und gibt die Daten als Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält die nächste Zeile aus dem Textreader oder null, wenn alle Zeichen gelesen wurden. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Liest alle Zeichen von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Zeichenfolge mit allen Zeichen von der aktuellen Position bis zum Ende des Textreaders. - E/A-Fehler. - Der ist geschlossen. - Es ist nicht genügend Speicherplatz vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zu reservieren. - Die Anzahl der Zeichen in der nächsten Zeile ist größer als . - 1 - - - Liest alle Zeichen asynchron von der aktuellen Position bis zum Ende des Text-Readers und gibt diese als eine Zeichenfolge zurück. - Eine Aufgabe, die den asynchronen Lesevorgang darstellt.Der Wert des -Parameters enthält eine Zeichenfolge mit den Zeichen von der aktuellen Position bis zum Ende des Textreaders. - Die Anzahl der Zeichen ist niedriger als . - Der Textreader wurde freigegeben. - Der Reader wird gerade durch einen früheren Lesevorgang verwendet. - - - Stellt einen Writer dar, der eine sequenzielle Serie von Zeichen schreiben kann.Diese Klasse ist abstrakt. - 2 - - - Initialisiert eine neue Instanz der -Klasse. - - - Initialisiert eine neue Instanz der -Klasse mit dem angegebenen Formatanbieter. - Ein -Objekt zum Steuern der Formatierung. - - - Speichert die für diesen TextWriter verwendeten Zeilenendemarken. - - - Gibt alle vom -Objekt verwendeten Ressourcen frei. - - - Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. - true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. - - - Gibt beim Überschreiben in einer abgeleiteten Klasse die Zeichencodierung zurück, in der die Ausgabe geschrieben ist. - Die Zeichencodierung, in der die Ausgabe geschrieben wird. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - 1 - - - Löscht sämtliche Puffer für den aktuellen Writer asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät. - Eine Aufgabe, die die asynchrone Leerung darstellt. - Der Textwriter wird freigegeben. - Der Writer wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Ruft ein Objekt zum Steuern der Formatierung ab. - Ein -Objekt für eine bestimmte Kultur oder die Formatierung der aktuellen Kultur, wenn keine andere Kultur angegeben wurde. - 2 - - - Ruft die Zeichenfolge für den Zeilenabschluss ab, die vom aktuellen TextWriter verwendet wird, oder legt diese fest. - Die Zeichenfolge für den Zeilenabschluss für den aktuellen TextWriter. - 2 - - - Stellt einen TextWriter ohne Sicherungsspeicher bereit, in den zwar geschrieben, aus dem jedoch nicht gelesen werden kann. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichenarray in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichenarray. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Objekts in die Textzeichenfolge oder den Stream, indem für das Objekt die ToString-Methode aufgerufen wird. - Das zu schreibende Objekt. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts in die Textzeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - - oder ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichenarray asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn den Wert null ist, wird nichts geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn den Wert null hat, wird nichts in den Stream geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen für den Zeilenabschluss in die Textzeichenfolge oder den Stream. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Boolean-Werts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Boolean-Wert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das in den Textstream zu schreibende Zeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das Zeichenarray, aus dem die Daten gelesen werden. - Die Zeichenposition im , an der mit dem Lesen von Daten begonnen werden soll. - Die maximale Anzahl der zu schreibenden Zeichen. - Die Länge des Puffers minus ist kleiner als . - Der -Parameter ist null. - - oder ist negativ. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines Dezimalwerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Der zu schreibende Dezimalwert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 8-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 8-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl mit Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt durch Aufrufen der ToString-Methode für ein Objekt die Textdarstellung dieses Objekts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Das zu schreibende Objekt.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung eines 4-Byte-Gleitkommawerts, gefolgt von einem Zeichen für den Zeilenabschluss, in die Zeichenfolge oder den Stream. - Der zu schreibende 4-Byte-Gleitkommawert. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende Zeichenfolge.Wenn null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (1 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile in die Textzeichenfolge oder den Stream unter Verwendung der gleichen Semantik wie die -Methode. - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (2 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Das erste zu formatierende und zu schreibende Objekt. - Das zweite zu formatierende und zu schreibende Objekt. - Das dritte zu formatierende und zu schreibende Objekt. - - ist null. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer/gleich der Anzahl der zu formatierenden Objekte (3 für diese Methodenüberladung). - 1 - - - Schreibt eine formatierte Zeichenfolge und eine neue Zeile unter Verwendung der gleichen Semantik wie bei . - Eine kombinierte Formatierungszeichenfolge (siehe Hinweise). - Ein Objektarray mit 0 (null) oder mehr zu formatierenden und zu schreibenden Objekten. - Eine Zeichenfolge oder ein Objekt wird als null übergeben. - Der ist geschlossen. - E/A-Fehler. - - ist keine gültige kombinierte Formatzeichenfolge.- oder - Der Index eines Formatelements ist kleiner als 0 (null) oder größer oder gleich der Länge des -Arrays. - 1 - - - Schreibt die Textdarstellung einer 4-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt die Textdarstellung einer 8-Byte-Ganzzahl ohne Vorzeichen, gefolgt von einem Zeichen für den Zeilenabschluss, in die Textzeichenfolge oder den Stream. - Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen. - Der ist geschlossen. - E/A-Fehler. - 1 - - - Schreibt ein Zeichen für den Zeilenabschluss asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichen. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Array von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das in den Textstream zu schreibende Zeichenarray.Wenn das Zeichenarray null ist, wird nur das Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt ein Teilarray von Zeichen, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Das Zeichenarray, aus dem Daten geschrieben werden sollen. - Die Zeichenposition im Puffer, an der mit dem Abrufen von Daten begonnen werden soll. - Die Anzahl der zu schreibenden Zeichen. - - ist null. - Der und ist größer als die Pufferlänge. - - oder ist negativ. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - Schreibt eine Zeichenfolge, gefolgt von einem Zeichen für den Zeilenabschluss, asynchron in die Textzeichenfolge oder den Stream. - Eine Aufgabe, die den asynchronen Schreibvorgang darstellt. - Die zu schreibende Zeichenfolge.Wenn der Wert null ist, wird nur ein Zeichen für den Zeilenabschluss geschrieben. - Der Textwriter wird freigegeben. - Der Textwriter wird derzeit von einem vorherigen Schreibvorgang verwendet. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml deleted file mode 100644 index 0b2c206b..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/es/System.IO.xml +++ /dev/null @@ -1,2090 +0,0 @@ - - - - System.IO - - - - Lee tipos de datos primitivos como valores binarios en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase basada en la secuencia especificada y usando codificación UTF-8. - La secuencia de entrada. - La secuencia no admite la lectura, es null, o ya está cerrada. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, deja la secuencia abierta. - La secuencia de entrada. - Codificación de caracteres que se utilizará. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - La secuencia no admite la lectura, es null, o ya está cerrada. - El valor de o es null. - - - Expone el acceso a la secuencia subyacente de . - Secuencia subyacente asociada a BinaryReader. - 2 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Rellena el búfer interno con el número especificado de bytes leídos de la secuencia. - Número de bytes que se va a leer. - Se llega al final de la secuencia antes de se ha podido leer. - Se produce un error de E/S. - Solicitado es mayor que el tamaño del búfer interno. - - - Devuelve el siguiente carácter disponible y no hace avanzar la posición de bytes o caracteres. - Siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - No se puede descodificar el carácter actual en el búfer de caracteres interno utilizando la seleccionado para la secuencia. - 2 - - - Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia. - Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes. - Número de bytes leídos en .Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de bytes que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres. - Número total de caracteres leídos en el búfer.Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia. - Búfer en el que se leen los datos. - Punto inicial del búfer en el que comienza la lectura. - Número de caracteres que se va a leer. - La longitud del búfer menos es menor que . o bienEl número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - El valor de es null. - - o es negativo. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero de 32 bits en formato comprimido. - Entero de 32 bits en formato comprimido. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - La secuencia está dañada. - - - Lee un valor Boolean de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Es true si el byte es distinto de cero; en caso contrario, es false. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el siguiente byte de la secuencia actual y hace avanzar un byte la posición actual de la secuencia. - Siguiente byte que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee el número especificado de bytes de la secuencia actual en una matriz de bytes y hace avanzar la posición actual en función del número de bytes leídos. - Matriz de bytes que contiene los datos leídos de la secuencia subyacente.Este podría ser inferior al número de bytes solicitado si se alcanza el final de la secuencia. - Número de bytes que se va a leer.Este valor debe ser 0 o un número no negativo o se producirá una excepción. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - Se produce un error de E/S. - La secuencia está cerrada. - - es negativo. - 2 - - - Lee el siguiente carácter de la secuencia actual y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lee de la secuencia. - Carácter que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - Se ha leído un carácter suplente. - 2 - - - Lee el número especificado de caracteres de la secuencia actual, devuelve los datos en una matriz de caracteres y hace avanzar la posición actual de acuerdo con la Encoding usada y el carácter concreto que se lee en la secuencia. - Matriz de caracteres que contiene los datos leídos de la secuencia subyacente.Podría ser inferior al número de caracteres solicitados si se alcanza el final de la secuencia. - Número de caracteres que se va a leer. - El número de caracteres descodificados para leer es mayor que .Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente. - La secuencia está cerrada. - Se produce un error de E/S. - - es negativo. - 2 - - - Lee un valor decimal de la secuencia actual y hace avanzar la posición actual de la secuencia dieciséis bytes. - Valor decimal que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 8 bytes de la secuencia actual y hace avanzar la posición actual de la secuencia en ocho bytes. - Valor de punto flotante de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 2 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en dos bytes. - Entero con signo de 2 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Entero con signo de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero con signo de 8 bytes de la secuencia actual y avanza la posición actual de la secuencia en ocho bytes. - Entero con signo de 8 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un byte con signo de esta secuencia y hace avanzar la posición actual de la secuencia en un byte. - Byte con signo que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un valor de punto flotante de 4 bytes en la secuencia actual y hace avanzar la posición actual de la secuencia en cuatro bytes. - Valor de punto flotante de 4 bytes que se lee en la secuencia actual. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee una cadena de la secuencia actual.La cadena tiene como prefijo la longitud, codificada como un entero de siete bits cada vez. - Cadena que se lee. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 2 bytes de la secuencia actual con la codificación "little-endian" y hace avanzar la posición de la secuencia en dos bytes. - Entero sin signo de 2 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 4 bytes de la secuencia actual y hace avanzar la posición de la secuencia en cuatro bytes. - Entero sin signo de 4 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - La secuencia está cerrada. - Se produce un error de E/S. - 2 - - - Lee un entero sin signo de 8 bytes de la secuencia actual y hace avanzar la posición de la secuencia en ocho bytes. - Entero sin signo de 8 bytes que se lee en esta secuencia. - Se llega al final de la secuencia. - Se produce un error de E/S. - La secuencia está cerrada. - 2 - - - Escribe tipos primitivos en binario en una secuencia y admite escribir cadenas en una codificación específica. - 2 - - - Inicializa una nueva instancia de la clase que escribe en una secuencia. - - - Inicializa una nueva instancia de la clase basada en la secuencia y usando codificación UTF-8. - Flujo de salida. - La secuencia no admite escritura o ya se encuentra cerrada. - - es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y codificación de caracteres especificadas. - Flujo de salida. - Codificación de caracteres que se utilizará. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Inicializa una nueva instancia de la clase basada en la secuencia y la codificación de caracteres especificadas y, opcionalmente, dejando abierta la secuencia. - Flujo de salida. - Codificación de caracteres que se utilizará. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - La secuencia no admite escritura o ya se encuentra cerrada. - El valor de o de es null. - - - Obtiene la secuencia subyacente del objeto . - Flujo subyacente asociado a BinaryWriter. - 1 - - - Libera todos los recursos usados por la instancia actual de la clase . - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Especifica un objeto sin memoria auxiliar. - 1 - - - Contiene la secuencia subyacente. - - - Establece la posición en la secuencia actual. - Posición con la secuencia actual. - Desplazamiento de bytes relacionado con . - Un campo de que indica el punto de referencia del que se obtiene la nueva posición. - El puntero de archivo se ha movido a una posición no válida. - El valor de no es válido. - 1 - - - Escribe un valor Boolean de un byte en la secuencia actual, que es 0 si es false y 1 si es true. - Valor Boolean que se va a escribir (0 ó 1). - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte sin signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte sin signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una matriz de bytes en la secuencia subyacente. - Matriz de bytes que contiene los datos que se van a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es null. - 1 - - - Escribe una región de una matriz de bytes en la secuencia actual. - Matriz de bytes que contiene los datos que se van a escribir. - Punto inicial de donde comenzará la escritura. - Número de bytes que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un carácter Unicode en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en la secuencia. - El carácter Unicode no suplente que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - - es un carácter suplente único. - 1 - - - Escribe una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y los caracteres específicos escritos en esa secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - - es null. - La secuencia está cerrada. - Se produce un error de E/S. - 1 - - - Escribe una sección de una matriz de caracteres en la secuencia actual y avanza la posición actual de la secuencia de acuerdo con el Encoding utilizado y quizás los caracteres específicos que se escriben en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Punto inicial de donde se empieza a leer. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - - es null. - - o son negativos. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor decimal en la secuencia actual y avanza la posición de la secuencia en dieciséis bytes. - Valor decimal que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Valor de punto flotante de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero con signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero con signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero con signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero con signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un byte con signo en la secuencia actual y avanza la posición de la secuencia en un byte. - Byte con signo que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un valor de punto flotante de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Valor de punto flotante de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe una cadena de longitud prefijada en esta secuencia en la codificación actual de y hace avanzar la posición actual de la secuencia de acuerdo con la codificación utilizada y los caracteres específicos escritos en dicha secuencia. - Valor que se va a escribir. - Se produce un error de E/S. - - es null. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de dos bytes en la secuencia actual y avanza la posición de la secuencia en dos bytes. - Entero sin signo de dos bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de cuatro bytes en la secuencia actual y avanza la posición de la secuencia en cuatro bytes. - Entero sin signo de cuatro bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero sin signo de ocho bytes en la secuencia actual y avanza la posición de la secuencia en ocho bytes. - Entero sin signo de ocho bytes que se va a escribir. - Se produce un error de E/S. - La secuencia está cerrada. - 1 - - - Escribe un entero de 32 bits en formato comprimido. - Entero de 32 bits que se va a escribir. - Se llega al final de la secuencia. - La secuencia está cerrada. - La secuencia está cerrada. - - - Excepción que se produce cuando se intenta realizar una operación de lectura más allá del final de una secuencia. - 2 - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en un mensaje proporcionado por el sistema y HRESULT establecido en COR_E_ENDOFSTREAM. - - - Inicializa una nueva instancia de la clase con la cadena de mensaje establecida en y HRESULT en COR_E_ENDOFSTREAM. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - - - Inicializa una nueva instancia de la clase con un mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. - Cadena que describe el error.Se pretende que el contenido de sea inteligible.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Excepción que se inicia cuando el formato de un flujo de datos no es válido. - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el mensaje de error especificado. - Mensaje de error que explica la razón de la excepción. - - - Inicializa una nueva instancia de la clase con una referencia a la excepción interna que representa la causa de esta excepción. - Mensaje de error que explica la razón de la excepción. - La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. - - - Crea una secuencia cuya memoria auxiliar es la memoria.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada con un valor cero. - - - Inicializa una nueva instancia invariable de la clase de acuerdo con la matriz de bytes especificada. - Matriz de bytes sin signo a partir de la cual se crea la secuencia actual. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la matriz de bytes especificada con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - - Inicializa una nueva instancia invariable de la clase según la región especificada (índice) de una matriz de bytes. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - El valor de es null. - - o es menor que cero. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia invariable de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - El valor de es null. - - o son negativos. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase según la región especificada de una matriz de bytes, con la propiedad establecida como se ha indicado y la posibilidad de llamar a establecida según lo especificado. - Matriz de bytes sin signo a partir de la cual se crea esta secuencia. - Índice en en el que empieza la secuencia. - Longitud de la secuencia en bytes. - Establecimiento de la propiedad , que determina si la secuencia admite escritura. - Es true para habilitar , que devuelve la matriz de bytes sin signo desde la cual se creó la secuencia; de lo contrario, es false. - El valor de es null. - - o es negativo. - La longitud del búfer menos es menor que . - - - Inicializa una nueva instancia de la clase con una capacidad expansible inicializada según lo especificado. - Tamaño inicial de la matriz interna en bytes. - - es negativo. - - - Obtiene un valor que indica si la secuencia actual admite lectura. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite búsquedas. - true si el flujo está abierto. - 2 - - - Obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 2 - - - Obtiene o establece el número de bytes asignados a esta secuencia. - Longitud de la parte utilizable del búfer para la secuencia. - Se establece una capacidad de modo que sea negativa o menor que la longitud actual de la secuencia. - La secuencia actual está cerrada. - set se invoca en una secuencia cuya capacidad no se puede modificar. - 2 - - - Lee asincrónicamente todos los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer especificado y el token de cancelación. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero. - Token para supervisar solicitudes de cancelación. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera los recursos no administrados usados que usa la clase y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Reemplaza el método de modo que no se realice ninguna acción. - 2 - - - De forma asincrónica borra todos los búferes de esta secuencia y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación. - Se ha eliminado la secuencia. - - - Obtiene la longitud de la secuencia en bytes. - Longitud de la secuencia en bytes. - La secuencia está cerrada. - 2 - - - Obtiene o establece la posición actual dentro de la secuencia. - Posición actual dentro de la secuencia. - La posición se establece en un valor negativo o un valor mayor que . - La secuencia está cerrada. - 2 - - - Lee un bloque de bytes de la secuencia actual y escribe los datos en un búfer. - Número total de bytes escritos en el búfer.Puede ser menor que el número de bytes solicitado si ese número de bytes no está disponible, o bien puede ser cero si se alcanza el final de la secuencia antes de que se lea algún byte. - Cuando este método finaliza, contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los caracteres leídos de la secuencia actual. - Posición de desplazamiento en bytes de base cero de en el que se comienza a almacenar los datos de la secuencia actual. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - - resta de la longitud del búfer es menor que . - La instancia de la secuencia actual está cerrada. - 2 - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia actual. - El byte convertido en un o -1 si se llega al final de la secuencia. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la posición dentro de la secuencia actual en el valor especificado. - Nueva posición dentro de la secuencia, calculada mediante la combinación del punto de referencia inicial y del desplazamiento. - Nueva posición dentro de la secuencia.Esta está relacionada con el parámetro y puede ser positiva o negativa. - Valor de tipo , que actúa como el punto de referencia de las operaciones de búsqueda. - Se ha intentado realizar una búsqueda antes del inicio de la secuencia. - - es mayor que . - Hay un no válido . o bien se produjo un desbordamiento aritmético. - La instancia de la secuencia actual está cerrada. - 2 - - - Establece la longitud de la secuencia actual en el valor especificado. - Valor en el que establecer la longitud. - La secuencia actual no es de tamaño variable y es mayor que la capacidad actual.o bien La secuencia actual no admite escritura. - - es negativo o es mayor que la longitud máxima de la , donde la longitud máxima es ( -origin), y el origen es el índice del búfer subyacente donde comienza la secuencia. - 2 - - - Escribe el contenido de la secuencia en una matriz de bytes, independientemente de la propiedad . - Nueva matriz de bytes. - 2 - - - Devuelve la matriz de bytes sin signo a partir de la cual se creó esta secuencia.El valor devuelto indica si la conversión se realizó correctamente. - Es true si la conversión se realiza correctamente; en caso contrario, es false. - El segmento de matriz de bytes desde el que se creó esta secuencia. - - - Escribe un bloque de bytes en la secuencia actual usando los datos leídos en un búfer. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número máximo de bytes que se pueden escribir. - El valor de es null. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual está más cerca que bytes al final de la secuencia y la capacidad no se puede modificar. - - resta de la longitud del búfer es menor que . - - o son negativos. - Se produce un error de E/S. - La instancia de la secuencia actual está cerrada. - 2 - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte en la posición actual de la secuencia actual. - Byte que se va a escribir. - La secuencia no es compatible con la escritura.Para obtener más información, vea .o bien La posición actual se encuentra al final de la secuencia y la capacidad no se puede modificar. - La secuencia actual está cerrada. - 2 - - - Escribe el contenido completo de esta secuencia de memoria en otra secuencia. - Secuencia en la que se va a escribir esta secuencia de memoria. - El valor de es null. - La secuencia actual o de destino está cerrada. - 2 - - - Especifica la posición usada para buscar en una secuencia. - 2 - - - Especifica el comienzo de una secuencia. - - - Especifica lo posición actual dentro de la secuencia. - - - Especifica el final de una secuencia. - - - Proporciona una vista genérica de una secuencia de bytes.Esta es una clase abstracta.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 2 - - - Inicializa una nueva instancia de la clase . - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite lectura. - true si la secuencia admite lectura; en caso contrario, false. - 1 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite búsquedas. - true si la secuencia admite búsquedas; en caso contrario, false. - 1 - - - Obtiene un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - Un valor que determina si se puede agotar el tiempo de espera de la secuencia actual. - 2 - - - Cuando se reemplaza en una clase derivada, obtiene un valor que indica si la secuencia actual admite escritura. - true si el flujo admite escritura; en caso contrario, false. - 1 - - - Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - La secuencia actual no admite lectura.o bien no se admite la escritura. - La secuencia de actual o se cerraron antes de la se llamó al método. - Error de E/S. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - El valor de es null. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. - Tarea que representa la operación de copia asincrónica. - Secuencia en la que se copiará el contenido de la secuencia actual. - Tamaño del búfer en bytes.Este valor debe ser mayor que cero.El tamaño predeterminado es 81920. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - es un valor negativo o es cero. - Se desecha la secuencia actual o la secuencia de destino. - La secuencia actual no admite lectura o la secuencia de destino no admite escritura. - - - Libera todos los recursos usados por . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, borra todos los búferes de esta secuencia y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Se produce un error de E/S. - 2 - - - Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Borra asincrónicamente todos los búferes del flujo actual, hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. - Tarea que representa la operación de vaciado asincrónico. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - Se ha eliminado la secuencia. - - - Cuando se reemplaza en una clase derivada, obtiene la longitud en bytes de la secuencia. - Un valor Long que representa la longitud de la secuencia en bytes. - Una clase derivada de Stream no admite la búsqueda. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Stream sin memoria auxiliar. - 1 - - - Cuando se reemplaza en una clase derivada, se obtiene o se establece la posición dentro de la secuencia actual. - Posición actual dentro de la secuencia. - Se produce un error de E/S. - La secuencia no admite búsquedas. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. - Número total de bytes leídos en el búfer.Puede ser menor que el número de bytes solicitado si dicho número no está disponible, o puede ser cero (0) si se alcanza el final de la secuencia. - Matriz de bytes.Cuando este método devuelve un valor, el búfer contiene la matriz de bytes especificada con valores entre y ( + - 1) reemplazada con los bytes leídos del origen actual. - Desplazamiento en bytes de base cero de donde se comienza a almacenar los datos leídos de la secuencia actual. - Número máximo de bytes que se deben leer de la secuencia actual. - La suma de y es mayor que la longitud del búfer. - El valor de es null. - - o es negativo. - Se produce un error de E/S. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Búfer en el que se escriben los datos. - Posición de desplazamiento en bytes de donde se comienza a escribir los datos del flujo. - Número máximo de bytes que se pueden leer. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no admite lectura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de lectura anterior. - - - Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. - Byte sin signo convertido en Int32,o bien -1 si está al final de la secuencia. - La secuencia no admite lectura. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de lectura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Cuando se reemplaza en una clase derivada, se establece la posición dentro de la secuencia actual. - La nueva posición dentro de la secuencia actual. - Desplazamiento de bytes relacionado con el parámetro . - Valor de tipo que indica el punto de referencia utilizado para obtener la nueva posición. - Se produce un error de E/S. - La secuencia no admite búsquedas, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 1 - - - Cuando se reemplaza en una clase derivada, se establece la longitud de la secuencia actual. - Longitud deseada de la secuencia actual, en bytes. - Se produce un error de E/S. - La secuencia no admite operaciones de lectura ni escritura, como en el caso donde la secuencia se cree a partir de los resultados de una canalización o consola. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. - Matriz de bytes.Este método copia bytes desde al flujo actual. - Desplazamiento en bytes de base cero en la en la que se comienzan a copiar los bytes en la secuencia actual. - Número de bytes que se deben escribir en la secuencia actual. - La suma de  y  es mayor que la longitud del búfer. - - es null. - - o  es negativo. - Se produjo un error de E/S, como no se puede encontrar el archivo especificado. - La secuencia no es compatible con la escritura. - - se llama después de cerrar la secuencia. - 1 - - - Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. - Tarea que representa la operación de escritura asincrónica. - Búfer del que se van a escribir datos. - Desplazamiento en bytes de base cero de desde donde se comienzan a copiar los bytes en la secuencia. - Número máximo de bytes que se pueden escribir. - Token para supervisar solicitudes de cancelación.El valor predeterminado es . - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - La secuencia no es compatible con la escritura. - Se ha eliminado la secuencia. - La secuencia está actualmente en uso por una operación de escritura anterior. - - - Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. - Byte que se debe escribir en la secuencia. - Se produce un error de E/S. - La secuencia no admite escritura o ya se encuentra cerrada. - Tras cerrar la secuencia, se llamó a algún método. - 2 - - - Obtiene o establece un valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - Valor, en milisegundos, que determina durante cuánto tiempo la secuencia intentará realizar operaciones de escritura antes de que se agote el tiempo de espera. - El método siempre produce una . - 2 - - - Implementa un que lee los caracteres de una secuencia de bytes en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el Reference Source. - 1 - - - Inicializa una nueva instancia de la clase para el flujo especificado. - Secuencia que se va a leer. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada, con la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de es null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada y con la codificación de caracteres indicada. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada y la opción especificada de detección de marcas de orden de bytes. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - - no se admite la lectura. - El valor de o es null. - - - Inicializa una nueva instancia de la clase de la secuencia especificada, con la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Indica si se deben buscar marcas de orden de byte al comienzo del archivo. - Tamaño mínimo de búfer. - La secuencia no admite lectura. - El valor de o es null. - - es menor o igual que cero. - - - Inicializa una nueva instancia de la clase de la secuencia especificada basada en la codificación de caracteres especificada, la opción especificada de detección de marcas de orden de bytes y el tamaño del búfer y, opcionalmente, deja abierta la secuencia. - Secuencia que se va a leer. - Codificación de caracteres que se utilizará. - Es true para buscar marcas de orden de byte al comienzo del archivo; en caso contrario, es false. - Tamaño mínimo de búfer. - true para dejar el flujo abierto después de desechar el objeto ; de lo contrario, false. - - - Devuelve la secuencia subyacente. - Secuencia subyacente. - 2 - - - Obtiene la codificación de caracteres que actualmente utiliza este objeto . - Codificación de caracteres que utiliza actualmente este lector.El valor puede ser diferente después de la primera llamada a cualquier método de , ya que la detección automática de la codificación no se realiza hasta la primera llamada a un método . - 2 - - - Borra el búfer interno. - 2 - - - Cierra la secuencia subyacente, libera los recursos no administrados que utiliza y, de forma opcional, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene un valor que indica si la actual posición está al final de la secuencia. - Es true si la actual posición está al final de la secuencia; en caso contrario, es false. - Se ha eliminado la secuencia subyacente. - 1 - - - Objeto en torno a una secuencia vacía. - 1 - - - Devuelve el siguiente carácter disponible pero no lo consume. - Entero que representa el siguiente carácter que se va a leer, o -1 si no hay caracteres que leer o si la secuencia no admite la operación de búsqueda. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter de la secuencia de entrada y hace avanzar la posición de los caracteres en un carácter. - El siguiente carácter de la secuencia de entrada que se representa como un objeto , o -1 si no hay más caracteres disponibles. - Se produce un error de E/S. - 1 - - - Lee un máximo especificado de caracteres de la secuencia actual en un búfer, comenzando en el índice especificado. - Número de caracteres leídos. Si se llega al final de la secuencia y no se leyó ningún dato es 0.El número será menor o igual que el parámetro , dependiendo de si los datos están disponibles dentro de la secuencia. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Índice de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - La longitud del búfer menos es menor que . - El valor de es null. - - o es negativo. - Se produce un error de E/S, como el cierre de la secuencia. - 1 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , dependiendo de si se han leído todos los caracteres de entrada. - El resultado que devuelve este método contiene la matriz de caracteres especificada con valores entre e () reemplazada por los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - - o es negativo. - El se cierra. - Error de E/S. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la secuencia actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la secuencia. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final de la secuencia se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - - o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Línea siguiente de la secuencia de entrada, o null si se alcanza el final de la secuencia de entrada. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica una línea de caracteres de la secuencia actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente de la secuencia, o es null si se han leído todos los caracteres. - El número de caracteres en la siguiente línea es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la secuencia. - Resto de la secuencia, como una cadena, desde la posición actual hasta el final.Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía (""). - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - Se produce un error de E/S. - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la secuencia y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la secuencia. - El número de caracteres es mayor que . - Se ha eliminado la secuencia. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir los caracteres de una secuencia en una codificación determinada.Para examinar el código fuente de .NET Framework para este tipo, consulte el fuente de referencia de. - 1 - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación UTF-8 y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - No se puede escribir en . - - is null. - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación especificada y el tamaño de búfer predeterminado. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - - o es null. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y el tamaño de búfer especificados. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Inicializa una nueva instancia de la clase para la secuencia especificada usando la codificación y tamaño de búfer especificados y, opcionalmente deja abierta la secuencia. - Secuencia en la que se va a escribir. - Codificación de caracteres que se utilizará. - Tamaño del búfer en bytes. - true para dejar la secuencia abierta después de desechar el objeto ; de lo contrario, false. - - o es null. - El valor de es negativo. - No se puede escribir en . - - - Obtiene o establece un valor que indica si vaciará su búfer en la secuencia subyacente después de cada llamada a . - Es true para que vacíe su búfer; en caso contrario, es false. - 1 - - - Obtiene la secuencia subyacente que interactúa con una memoria auxiliar. - Secuencia en la que escribe este StreamWriter. - 2 - - - Libera los recursos no administrados que usa y, de forma opcional, libera los recursos administrados. - truepara liberar los recursos administrados y no administrados; false para liberar únicamente los recursos no administrados. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - - - Obtiene el donde se escribe el resultado. - - especificado en el constructor para la instancia actual o si no se ha especificado una codificación. - 2 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en la secuencia subyacente. - El sistema de escritura actual está cerrado. - Se produjo un error de E/S. - La codificación actual no admite que se muestre la mitad de un par suplente Unicode. - 1 - - - Borra todos los búferes para esta secuencia de forma asincrónica y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se ha eliminado la secuencia. - - - Proporciona un StreamWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe un carácter en la secuencia. - Carácter que se va a escribir en la secuencia. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una matriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir.Si es null, no se escribe nada. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una submatriz de caracteres en la secuencia. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - Se produce un error de E/S. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - 1 - - - Escribe una cadena en la secuencia. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - - es true o el búfer está lleno, y el sistema de escritura actual está cerrado. - - es true o el búfer está lleno, y el contenido del búfer no puede escribirse en la secuencia de tamaño fijo subyacente porque se encuentra al final de la secuencia. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que contiene los datos que se van a escribir. - Posición del carácter en el búfer donde comienza la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se debe escribir en la secuencia.Si es null, no se escribe nada. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la lectura de datos. - Número máximo de caracteres que se van a escribir. - - is null. - La suma de y es mayor que la longitud del búfer. - El valor de o es negativo. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la secuencia. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de secuencias. - El escritor de secuencias está actualmente en uso por una operación de escritura anterior. - - - Implementa que lee en una cadena. - 2 - - - Inicializa una nueva instancia de la clase que lee en la cadena especificada. - Cadena en la que debe inicializarse. - El parámetro es null. - - - Libera los recursos no administrados que utiliza la clase y, opcionalmente, libera los recursos administrados. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Devuelve el siguiente carácter disponible pero no lo consume. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si la secuencia no admite la operación de búsqueda. - El sistema de lectura actual está cerrado. - 2 - - - Lee el siguiente carácter de la cadena de entrada y hace avanzar la posición de los caracteres en un carácter. - Siguiente carácter de la cadena subyacente, o -1 si no hay más caracteres disponibles. - El sistema de lectura actual está cerrado. - 2 - - - Lee un bloque de caracteres de la cadena de entrada y hace avanzar la posición de los caracteres en . - Número total de caracteres leídos en el búfer.Puede ser menor que el número de caracteres solicitado si dicho número de caracteres no está disponible, o puede ser cero si se alcanza el final de la cadena subyacente. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Índice inicial del búfer. - Número de caracteres que se va a leer. - - es null. - La longitud del búfer menos es menor que . - - o son negativos. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee de forma asincrónica un número máximo de caracteres especificado en la cadena actual y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final de la cadena. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se pueden leer.Si el final de la cadena se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - - es null. - - o son negativos. - La suma de y es mayor que la longitud del búfer. - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Línea siguiente de la cadena actual, o null si se alcanza el final de la cadena. - El sistema de lectura actual está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - 2 - - - Lee de forma asincrónica una línea de caracteres de la cadena actual y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de cadenas, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Contenido desde la posición actual hasta el final de la cadena subyacente. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El sistema de lectura actual está cerrado. - 2 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final de la cadena y los devuelve como una cadena única. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final de la cadena. - El número de caracteres es mayor que . - El lector de cadenas se ha desechado. - El lector está actualmente en uso por una operación de lectura anterior. - - - Implementa para escribir información en una cadena.La información se almacena en el subyacente. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Inicializa una nueva instancia de la clase que escribe en el especificado. - Objeto StringBuilder en el que se va a escribir. - - es null. - - - Inicializa una nueva instancia de la clase que escribe en el especificado y tiene el control de formato especificado. - Objeto StringBuilder en el que se va a escribir. - Objeto que controla las operaciones de formato. - - es null. - - - Libera los recursos no administrados que utiliza y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Obtiene el donde se escribe el resultado. - Encoding donde se escribe el resultado. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - - - Devuelve el subyacente. - Objeto StringBuilder subyacente. - 2 - - - Devuelve una cadena que contiene los caracteres escritos hasta el momento en el StringWriter actual. - Cadena que contiene los caracteres escritos en el StringWriter actual. - 2 - - - Escribe un carácter en la cadena. - Carácter que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe una submatriz de caracteres en la cadena. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - - o son negativos. - ( + ) > .Length. - El sistema de escritura está cerrado. - 2 - - - Escribe una cadena en la cadena actual. - Cadena que se va a escribir. - El sistema de escritura está cerrado. - 2 - - - Escribe un carácter en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena actual de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica de línea en la cadena. - Tarea que representa la operación de escritura asincrónico. - Carácter que se va a escribir en la cadena. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena de forma asincrónica. - Tarea que representa la operación de escritura asincrónico. - Matriz de caracteres de la que se escriben los datos. - La posición en el búfer en el que se va a empezar a leer datos. - Número máximo de caracteres que se van a escribir. - - es null. - La suma de y es mayor que la longitud del búfer. - - o son negativos. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguida de un terminador de línea de forma asincrónica en la cadena actual. - Tarea que representa la operación de escritura asincrónico. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de cadenas. - El sistema de escritura de cadenas está actualmente en uso por una operación de escritura anterior. - - - Representa un lector que puede leer una serie secuencial de caracteres. - 2 - - - Inicializa una nueva instancia de la clase . - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true si se van a liberar los recursos administrados y no administrados; es false si se van a liberar únicamente los recursos no administrados. - - - Proporciona un TextReader sin datos del que leer. - 1 - - - Lee el siguiente carácter sin modificar el estado del sistema de lectura o el origen del carácter.Devuelve el siguiente carácter disponible sin leerlo realmente del lector. - Un entero que representa el siguiente carácter que se va a leer, o -1 si no hay más caracteres disponibles o si el lector no admite la operación de búsqueda. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee el siguiente carácter en el lector de texto y hace avanzar la posición de los caracteres en un carácter. - Carácter siguiente del lector de texto o -1 si no hay más caracteres disponibles.La implementación predeterminada devuelve -1. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si los datos están disponibles dentro del lector.Este método devuelve 0 (cero) si se llama cuando no quedan más caracteres para leer. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del lector se alcanza antes de escribir el número de caracteres especificado en el búfer, el método vuelve. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 1 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee un número máximo de caracteres especificado en el lector de texto actual y escribe los datos en un búfer, comenzando en el índice especificado. - Número de caracteres que se han leído.Este número será menor o igual que , en función de si se han leído todos los caracteres de entrada. - Cuando este método finaliza, este parámetro contiene la matriz de caracteres especificada con valores entre e ( + -1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer. - El valor de es null. - La longitud del búfer menos es menor que . - El valor de o es negativo. - El objeto está cerrado. - Se produce un error de E/S. - 2 - - - Lee un número máximo de caracteres especificado en el lector de texto actual de forma asincrónica y escribe los datos en un búfer, comenzando en el índice especificado. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene el número total de bytes leídos en el búfer.El valor del resultado puede ser menor que el número de bytes solicitados si el número de bytes disponibles actualmente es menor que el número solicitado o puede ser 0 (cero) si se ha llegado al final del texto. - Cuando este método finaliza, contiene la matriz de caracteres especificada con valores entre e ( + - 1) reemplazada con los caracteres leídos del origen actual. - Lugar de en el que comenzará la escritura. - Número máximo de caracteres que se van a leer.Si el final del texto se alcanza antes de leer el número de caracteres especificado en el búfer, el método actual vuelve. - El valor de es null. - El valor de o es negativo. - La suma de y es mayor que la longitud del búfer. - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee una línea de caracteres del lector de texto y devuelve los datos como una cadena. - Línea siguiente del lector o null si se han leído todos los caracteres. - Se produce un error de E/S. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El objeto está cerrado. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica una línea de caracteres y devuelve los datos como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene la línea siguiente del lector de texto, o es null si se han leído todos los caracteres. - El número de caracteres de la siguiente línea es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Lee todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Cadena que contiene todos los caracteres desde la posición actual hasta el final del lector. - Se produce un error de E/S. - El objeto está cerrado. - No hay memoria suficiente como para asignar un búfer a la cadena devuelta. - El número de caracteres de la siguiente línea es mayor que - 1 - - - Lee de forma asincrónica todos los caracteres desde la posición actual hasta el final del lector de texto y los devuelve como una cadena. - Tarea que representa la operación de lectura asincrónica.El valor del parámetro contiene una cadena con los caracteres desde la posición actual hasta el final del lector de texto. - El número de caracteres es mayor que . - Se ha desechado el lector de texto. - El lector está actualmente en uso por una operación de lectura anterior. - - - Representa un sistema de escritura que puede escribir una serie secuencial de caracteres.Esta clase es abstracta. - 2 - - - Inicializa una nueva instancia de la clase . - - - Inicializa una nueva instancia de la clase con el control de formato especificado. - Objeto que controla las operaciones de formato. - - - Almacena los caracteres de nueva línea usados para el TextWriter. - - - Libera todos los recursos utilizados por el objeto . - - - Libera los recursos no administrados que usa y libera los recursos administrados de forma opcional. - Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. - - - Cuando se reemplaza en una clase derivada, devuelve la codificación de caracteres en que se escribe el resultado. - Codificación de caracteres donde se escriben los resultados. - 1 - - - Borra todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - 1 - - - Borra asincrónicamente todos los búferes del sistema de escritura actual y hace que todos los datos almacenados en el búfer se escriban en el dispositivo subyacente. - Tarea que representa la operación de vaciado asincrónico. - Se desecha el sistema de escritura de texto. - El sistema de escritura está actualmente en uso por una operación de escritura anterior. - - - Obtiene un objeto que controla las operaciones de formato. - Objeto para una referencia cultural específica o para las operaciones de formato de la referencia cultural actual si no se especificó otra referencia cultural. - 2 - - - Obtiene o establece la cadena de terminador de línea usada por el TextWriter actual. - Cadena de terminador de línea para el TextWriter actual. - 2 - - - Proporciona un TextWriter sin memoria auxiliar, en el que se puede escribir pero no se puede leer. - 1 - - - Escribe la representación de texto de un valor Boolean en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto en la cadena o secuencia de texto mediante una llamada al método ToString en ese objeto. - Objeto que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena en la cadena o secuencia de texto. - Cadena que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero) o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato en la cadena de texto o en la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - El valor de o es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si es null, no se escribe nada. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena en la cadena o secuencia de texto de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si es null, no se escribirá nada en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un terminador de línea en la cadena o secuencia. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor Boolean seguida de un terminador de línea en la cadena o secuencia de texto. - Valor Boolean que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un carácter seguido de un terminador en la cadena o la secuencia de texto. - Carácter que se va a escribir en la secuencia de texto. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una matriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una submatriz de caracteres seguida de un terminador de línea en la cadena o secuencia de texto. - Matriz de caracteres de la que se leen los datos. - Posición del carácter en donde comenzar a leer datos. - Número máximo de caracteres que se van a escribir. - La longitud del búfer menos es menor que . - El parámetro es null. - - o es negativo. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor decimal seguida de un terminador de línea en la cadena o secuencia de texto. - Valor decimal que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 8 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero con signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes con signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un objeto mediante una llamada al método ToString en ese objeto, seguida de un terminador de línea en la cadena o secuencia de texto. - Objeto que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un valor de punto flotante de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Valor de punto flotante de 4 bytes que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena seguida de un terminador en la cadena o la secuencia de texto. - Cadena que se va a escribir.Si es null, sólo se escribe el terminador de línea. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - El objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es uno). - 1 - - - Escribe una cadena con formato y una nueva línea en la cadena de texto o a la secuencia, con la misma semántica que el método de . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es dos). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Primer objeto al que se va a dar formato y escribir. - Segundo objeto al que se va a dar formato y escribir. - Tercer objeto al que se va a dar formato y escribir. - El valor de es null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que el número de objetos a los que se va a dar formato (que, para esta sobrecarga del método, es tres). - 1 - - - Escribe una cadena con formato y una nueva línea usando la misma semántica que . - Cadena de formato compuesto (vea Comentarios). - Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato y escribir. - Una cadena u objeto se pasa como null. - El se cierra. - Se produce un error de E/S. - - no es una cadena de formato compuesto válido.o bien El índice de un elemento de formato es menor que 0 (cero), o mayor o igual que la longitud de la matriz. - 1 - - - Escribe la representación de texto de un entero sin signo de 4 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 4 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe la representación de texto de un entero sin signo de 8 bytes seguida de un terminador de línea en la cadena o secuencia de texto. - Entero de 8 bytes sin signo que se va a escribir. - El se cierra. - Se produce un error de E/S. - 1 - - - Escribe un terminador de línea en la cadena o secuencia de forma asincrónica. - Tarea que representa la operación de escritura asincrónica. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe un carácter seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Carácter que se va a escribir en la secuencia de texto. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una matriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres que se va a escribir en la secuencia de texto.Si la matriz de caracteres es null, sólo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una submatriz de caracteres seguida de un terminador de línea de forma asincrónica en la cadena o secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Matriz de caracteres de la que se escriben los datos. - Posición del carácter en el búfer donde comenzar la recuperación de datos. - Número de caracteres que se van a escribir. - El valor de es null. - El plus es mayor que la longitud del búfer. - - o es negativo. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - Escribe una cadena seguido de un terminador de forma asincrónica en la cadena o la secuencia de texto. - Tarea que representa la operación de escritura asincrónica. - Cadena que se va a escribir.Si el valor es null, solo se escribe el terminador de línea. - Se desecha el sistema de escritura de texto. - El sistema de escritura de texto está actualmente en uso por una operación de escritura anterior. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml deleted file mode 100644 index 30dc29ab..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/fr/System.IO.xml +++ /dev/null @@ -1,2201 +0,0 @@ - - - - System.IO - - - - Lit les types de données primitifs sous forme de valeurs binaires avec un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux d'entrée. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - - Initialise une nouvelle instance de la classe en fonction du flux et l'encodage de caractères spécifiés. - Flux d'entrée. - Encodage des caractères à utiliser. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux d'entrée. - Encodage des caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture, il est null ou bien il est déjà fermé. - - ou a la valeur null. - - - Expose l'accès au flux sous-jacent de l'élément . - Flux sous-jacent associé à l'élément BinaryReader. - 2 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplit la mémoire tampon interne avec le nombre spécifié d'octets lus à partir du flux. - Nombre d'octets à lire. - La fin du flux est atteinte avant que n'ait pu être lu. - Une erreur d'E/S se produit. - - demandé est plus grand que la taille de la mémoire tampon interne. - - - Retourne le prochain caractère disponible et n'avance pas la position de caractère ou d'octet. - Prochain caractère disponible, ou -1 si aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - Le caractère actuel ne peut pas être décodé dans la mémoire tampon de caractères interne à l'aide du sélectionné pour le flux de données. - 2 - - - Lit les caractères du flux sous-jacent et avance la position actuelle du flux conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Caractère suivant du flux d'entrée, ou -1 si aucun caractère n'est actuellement disponible. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Lit le nombre spécifié d'octets dans le flux, en commençant à un point spécifié dans le tableau d'octets. - Nombre d'octets lus dans .Ce total peut être inférieur au nombre d'octets demandé si ce nombre d'octets n'est pas disponible, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre d'octets à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié de caractères du flux, en commençant à un point spécifié dans le tableau de caractères. - Nombre total de caractères lus dans la mémoire tampon.Ce total peut être inférieur au nombre de caractères demandé si ce nombre de caractères n'est pas disponible actuellement, ou il peut être égal à zéro si la fin du flux est atteinte. - Mémoire tampon dans laquelle lire les données. - Point de départ, dans la mémoire tampon, à partir duquel commencer la lecture de la mémoire tampon. - Nombre de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . ouLe nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - - a la valeur null. - - ou est négatif. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier 32 bits au format compressé. - Entier 32 bits au format compressé. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Le flux est endommagé. - - - Lit une valeur Boolean à partir du flux actuel et avance la position actuelle du flux d'un octet. - true si l'octet est différent de zéro ; sinon, false. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit l'octet suivant du flux actuel et avance la position actuelle du flux d'un octet. - Octet suivant lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit le nombre spécifié d'octets du flux actuel dans un tableau d'octets et avance la position actuelle de ce nombre d'octets. - Tableau d'octets contenant les données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre d'octets demandé si la fin du flux est atteinte. - Nombre d'octets à lire.Cette valeur doit être 0 ou un nombre non négatif, sinon une exception se produit. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Une erreur d'E/S se produit. - Le flux est fermé. - - est négatif. - 2 - - - Lit le caractère suivant dans le flux actuel et avance la position actuelle du flux conformément à la valeur Encoding utilisée et du caractère spécifique en cours de lecture dans le flux. - Caractère lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - Un caractère de substitution a été lu. - 2 - - - Lit le nombre spécifié de caractères dans le flux actuel, retourne les données dans un tableau de caractères et avance la position actuelle conformément à la valeur Encoding utilisée et au caractère spécifique en cours de lecture dans le flux. - Tableau de caractères contenant des données lues dans le flux sous-jacent.Cette valeur peut être inférieure au nombre de caractères demandés si la fin du flux est atteinte. - Nombre de caractères à lire. - Le nombre de caractères décodés à lire est supérieur à .Cela peut arriver si un décodeur Unicode retourne des caractères de secours ou une paire de substitution. - Le flux est fermé. - Une erreur d'E/S se produit. - - est négatif. - 2 - - - Lit une valeur décimale dans le flux actuel et avance la position actuelle du flux de 16 octets. - Valeur décimale lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Valeur à virgule flottante de 8 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 2 octets dans le flux actuel et avance la position actuelle du flux de deux octets. - Entier signé de 2 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Entier signé de 4 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier signé de 8 octets dans le flux actuel et avance la position actuelle du flux de huit octets. - Entier signé de 8 octets lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un octet signé dans ce flux et avance la position actuelle du flux d'un octet. - Octet signé lu dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position actuelle du flux de quatre octets. - Valeur à virgule flottante de 4 octets lue dans le flux actuel. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit une chaîne dans le flux actuel.La chaîne est précédée de la longueur, encodée sous la forme d'un entier de sept bits à la fois. - Chaîne en cours de lecture. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 2 octets dans le flux actuel à l'aide de l’encodage Little Endian et avance la position du flux de deux octets. - Entier non signé de 2 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de quatre octets. - Entier non signé de 4 octets lu dans ce flux. - La fin du flux est atteinte. - Le flux est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de huit octets. - Entier non signé de 8 octets lu dans ce flux. - La fin du flux est atteinte. - Une erreur d'E/S se produit. - Le flux est fermé. - 2 - - - Écrit des types primitifs en binaire dans un flux et prend en charge l'écriture de chaînes dans un encodage spécifique. - 2 - - - Initialise une nouvelle instance de la classe qui écrit dans un flux. - - - Initialise une nouvelle instance de la classe en fonction du flux spécifié et à l'aide de l'encodage UTF-8. - Flux de sortie. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - a la valeur null. - - - Initialise une nouvelle instance de la classe en fonction du flux et de l'encodage de caractères spécifiés. - Flux de sortie. - Encodage de caractères à utiliser. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Initialise une nouvelle instance de la classe selon le flux et l'encodage de caractères spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux de sortie. - Encodage de caractères à utiliser. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - - ou est null. - - - Obtient le flux sous-jacent de . - Flux sous-jacent associé à BinaryWriter. - 1 - - - Libère toutes les ressources utilisées par l'instance actuelle de la classe . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - 1 - - - Spécifie sans magasin de sauvegarde. - 1 - - - Contient le flux sous-jacent. - - - Définit la position dans le flux actuel. - Position dans le flux actuel. - Offset d'octet par rapport à . - Champ de indiquant le point de référence à partir duquel la nouvelle position doit être obtenue. - Le pointeur de fichier a été déplacé vers un emplacement non valide. - La valeur n'est pas valide. - 1 - - - Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true. - Valeur Boolean à écrire (0 ou 1). - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet non signé dans le flux actuel et avance la position du flux d'un octet. - Octet non signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un tableau d'octets dans le flux sous-jacent. - Tableau d'octets contenant les données à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - a la valeur null. - 1 - - - Écrit une zone d'un tableau d'octets dans le flux actuel. - Tableau d'octets contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre d'octets à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Caractère Unicode de non-substitution à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - - est un caractère de substitution unique. - 1 - - - Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d'écriture dans le flux. - Tableau de caractères contenant les données à écrire. - - a la valeur null. - Le flux est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit dans le flux actuel une section d'un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits. - Tableau de caractères contenant les données à écrire. - Point de départ de à partir duquel l'écriture doit commencer. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets. - Valeur décimale à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Valeur à virgule flottante de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un octet signé dans le flux actuel et avance la position du flux d'un octet. - Octet signé à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Valeur à virgule flottante de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit dans ce flux une chaîne préfixée par sa longueur dans l'encodage actuel de et avance la position actuelle du flux en fonction de l'encodage utilisé et des caractères spécifiques écrits dans le flux. - Valeur à écrire. - Une erreur d'E/S se produit. - - a la valeur null. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets. - Entier non signé de 2 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets. - Entier non signé de 4 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets. - Entier non signé de 8 octets à écrire. - Une erreur d'E/S se produit. - Le flux est fermé. - 1 - - - Écrit un nombre entier 32 bits dans un format compressé. - Entier 32 bits à écrire. - La fin du flux est atteinte. - Le flux est fermé. - Le flux est fermé. - - - Exception levée en cas de tentative de lecture au-delà de la fin du flux. - 2 - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à un message fourni par le système et HRESULT équivaut à COR_E_ENDOFSTREAM. - - - Initialise une nouvelle instance de la classe dont la chaîne de message correspond à et HRESULT équivaut à COR_E_ENDOFSTREAM. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. - Chaîne qui décrit l'erreur.Le contenu du doit être compréhensible pour les utilisateurs.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Exception qui est levée lorsque le format d'un flux de données n'est pas valide. - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. - Message d'erreur indiquant la raison de l'exception. - - - Initialise une nouvelle instance de la classe avec une référence à l'exception interne qui est la cause de cette exception. - Message d'erreur indiquant la raison de l'exception. - Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. - - - Crée un flux dont le magasin de stockage est la mémoire.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à zéro. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié. - Tableau d'octets non signés à partir duquel créer le flux actuel. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction du tableau d'octets spécifié, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région (index) spécifiée d'un tableau d'octets. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - - a la valeur null. - - ou est inférieur à zéro. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance non redimensionnable de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe en fonction de la région spécifiée d'un tableau d'octets, avec la propriété spécifiée et la possibilité d'appeler comme spécifié. - Tableau d'octets non signés à partir duquel créer ce flux. - Index dans auquel commence le flux. - Longueur du flux en octets. - Définition de la propriété , qui détermine si le flux prend en charge l'écriture. - true pour activer , qui retourne le tableau d'octets non signés à partir duquel le flux a été créé ; sinon, false. - - a la valeur null. - - ou est négatif. - La longueur de la mémoire tampon moins est inférieure à . - - - Initialise une nouvelle instance de la classe avec une capacité extensible initialisée à la valeur spécifiée. - Taille initiale du tableau interne, en octets. - - est négatif. - - - Obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux est ouvert. - 2 - - - Obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 2 - - - Obtient ou définit le nombre d'octets alloués pour ce flux. - Longueur de la partie de la mémoire tampon qui peut être utilisée pour le flux. - La capacité définie correspond à une valeur négative ou est inférieure à la longueur actuelle du flux. - Le flux actuel est fermé. - set est appelé sur un flux dont la capacité ne peut pas être modifiée. - 2 - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro. - Jeton pour surveiller les demandes d'annulation. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère les ressources non managées utilisées par la classe et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Remplace la méthode afin qu'aucune action ne soit effectuée. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation. - Le flux a été supprimé. - - - Obtient la longueur du flux en octets. - Longueur du flux en octets. - Le flux est fermé. - 2 - - - Obtient ou définit la position actuelle dans le flux. - Position actuelle dans le flux. - La position correspond à une valeur négative ou à une valeur supérieure à . - Le flux est fermé. - 2 - - - Lit un bloc d'octets à partir du flux actuel et écrit les données dans une mémoire tampon. - Nombre total d'octets écrits dans la mémoire tampon.Ce total peut être inférieur au nombre d'octets demandés si ce nombre d'octets n'est pas actuellement disponible, ou égal à zéro si la fin du flux a été atteinte avant que des octets soient lus. - Quand cette méthode retourne un résultat, contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les caractères lus dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données à partir du flux actuel. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - - soustrait à la longueur de la mémoire tampon est inférieur à . - L'instance du flux actuel est fermée. - 2 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet dans le flux actuel. - Conversion du type (transtypage) de l'octet en , ou -1 si la fin du flux a été atteinte. - L'instance du flux actuel est fermée. - 2 - - - Définit la position dans le flux actuel à la valeur spécifiée. - Nouvelle position dans le flux, calculée en combinant le point de référence initial et le décalage. - Nouvelle position dans le flux.Elle est relative au paramètre et peut être positive ou négative. - Valeur de type , qui sert de point de référence à la recherche. - Tentative de recherche avant le début du flux. - - est supérieur à . - Un n'est pas valide. ou a entraîné des dépassements de capacité arithmétiques. - L'instance du flux actuel est fermée. - 2 - - - Définit la longueur du flux actuel à la valeur spécifiée. - Valeur à laquelle définir la longueur. - Le flux actuel n'est pas redimensionnable et est supérieur à la capacité actuelle.ou Le flux actuel ne prend pas en charge l'écriture. - - est négatif ou supérieur à la longueur maximale de , où la longueur maximale est ( - origine), et l'origine est l'index dans la mémoire tampon sous-jacente auquel commence le flux. - 2 - - - Écrit le contenu du flux dans un tableau d'octets, indépendamment de la propriété . - Nouveau tableau d'octets. - 2 - - - Retourne le tableau d'octets non signés à partir duquel ce flux a été créé.La valeur de retour indique si la conversion a réussi. - true si la conversion a réussi ; sinon, false. - Segment de tableau d'octets à partir duquel ce flux a été créé. - - - Écrit un bloc d'octets dans le flux actuel en utilisant des données lues dans une mémoire tampon. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre maximal d'octets à écrire. - - a la valeur null. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à moins de octets de la fin du flux et la capacité ne peut pas être modifiée. - - soustrait à la longueur de la mémoire tampon est inférieur à . - - ou est négatif. - Une erreur d'E/S se produit. - L'instance du flux actuel est fermée. - 2 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux actuel. - Octet à écrire. - Le flux ne prend pas en charge l'écriture.Pour plus d'informations, consultez .ou La position actuelle est à la fin du flux et la capacité ne peut pas être modifiée. - Le flux actuel est fermé. - 2 - - - Écrit le contenu complet de ce flux de mémoire dans un autre flux. - Flux dans lequel écrire ce flux de mémoire. - - a la valeur null. - Le flux en cours ou le flux cible est fermé. - 2 - - - Spécifie la position au sein d'un flux à utiliser pour la recherche. - 2 - - - Spécifie le début d'un flux. - - - Spécifie la position actuelle au sein d'un flux. - - - Spécifie la fin d'un flux. - - - Fournit une vue générique d'une séquence d'octets.Il s'agit d'une classe abstraite.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 2 - - - Initialise une nouvelle instance de la classe . - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la lecture. - true si le flux prend en charge la lecture ; sinon, false. - 1 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge la recherche. - true si le flux prend en charge la recherche ; sinon, false. - 1 - - - Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - Valeur qui détermine si le flux actuel peut dépasser le délai d'attente. - 2 - - - En cas de remplacement dans une classe dérivée, obtient une valeur indiquant si le flux actuel prend en charge l'écriture. - true si le flux prend en charge l'écriture ; sinon, false. - 1 - - - Lit les octets du flux actuel et les écrit dans un autre flux. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Flux vers lequel le contenu du flux actuel sera copié. - Taille de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux actuel ne prend pas en charge la lecture.ou ne prend pas en charge l'écriture. - Le flux actuel ou de a été fermé avant l'appel de la méthode . - Une erreur d'E/S s'est produite. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - - a la valeur null. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés. - Tâche qui représente l'opération de copie asynchrone. - Flux vers lequel le contenu du flux actuel sera copié. - Taille en octets de la mémoire tampon.Cette valeur doit être supérieure à zéro.La taille par défaut est 81920. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - est négatif ou égal à zéro. - Le flux de données actuel ou le flux de données de destination est supprimé. - Le flux de données actuel ne prend pas en charge la lecture, ou le flux de données de destination ne prend pas en charge l'écriture. - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de remplacement dans une classe dérivée, efface toutes les mémoires tampons pour ce flux et provoque l'écriture de toutes les données se trouvant dans des mémoires tampons sur l'appareil sous-jacent. - Une erreur d'E/S se produit. - 2 - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les demandes d'annulation. - Tâche qui représente l'opération de vidage asynchrone. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - Le flux a été supprimé. - - - En cas de remplacement dans une classe dérivée, obtient la longueur du flux en octets. - Valeur de type long représentant la longueur du flux en octets. - Une classe dérivée de Stream ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Élément Stream sans magasin de stockage. - 1 - - - En cas de remplacement dans une classe dérivée, obtient ou définit la position dans le flux actuel. - Position actuelle dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Nombre total d'octets lus dans la mémoire tampon.Le nombre d'octets peut être inférieur au nombre d'octets demandés si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte. - Tableau d'octets.Quand cette méthode retourne un résultat, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre et ( +  - 1) sont remplacées par les octets lus dans la source actuelle. - Dans , décalage d'octet de base zéro auquel commencer le stockage des données lues dans le flux actuel. - Nombre maximal d'octets à lire dans le flux actuel. - La somme de et de est supérieure à la longueur de la mémoire tampon. - - a la valeur null. - - ou est négatif. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Mémoire tampon dans laquelle les données sont écrites. - Dans , décalage d'octet auquel commencer l'écriture des données à partir du flux. - Nombre maximal d'octets à lire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - Le flux a été supprimé. - Le flux est en cours d'utilisation par une opération de lecture précédente. - - - Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte. - Conversion de type (transtypage) de l'octet non signé en Int32, ou -1 si la fin du flux a été atteinte. - Le flux ne prend pas en charge la lecture. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant d’expiration du délai d’attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'effectuer la lecture avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - En cas de remplacement dans une classe dérivée, définit la position dans le flux actuel. - Nouvelle position dans le flux actuel. - Offset d'octet par rapport au paramètre . - Valeur de type indiquant le point de référence utilisé pour obtenir la nouvelle position. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 1 - - - En cas de substitution dans une classe dérivée, définit la longueur de flux actuel. - Longueur souhaitée du flux actuel en octets. - Une erreur d'E/S se produit. - Le flux ne prend en charge ni l'écriture, ni la recherche, comme s'il était construit à partir d'un canal ou d'une sortie console. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits. - Tableau d'octets.Cette méthode copie octets à partir de dans le flux actuel. - Dans , décalage d'octet de base zéro auquel commencer la copie des octets dans le flux actuel. - Nombre d'octets à écrire dans le flux actuel. - La somme des  et  est supérieure à la longueur du tampon. - - est null. - - ou  est un nombre négatif. - Une erreur d'e/s est survenue, tels que le fichier spécifié est introuvable. - Le flux ne prend pas en charge l'écriture. - - a été appelée une fois que le flux a été fermé. - 1 - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation. - Tâche qui représente l'opération d'écriture asynchrone. - Mémoire tampon dont sont issues les données à écrire. - Dans , décalage d'octet de base zéro à partir duquel commencer la copie des octets dans le flux. - Nombre maximal d'octets à écrire. - Jeton pour surveiller les demandes d'annulation.La valeur par défaut est . - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux ne prend pas en charge l'écriture. - Le flux a été supprimé. - Le flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux. - Octet à écrire dans le flux. - Une erreur d'E/S se produit. - Le flux ne prend pas en charge l'écriture ou bien il est déjà fermé. - Des méthodes ont été appelées après que le flux a été fermé. - 2 - - - Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant l’expiration du délai d'attente. - Valeur exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d'écrire des données avant de dépasser le délai d'attente. - La méthode lève toujours . - 2 - - - Implémente qui lit les caractères à partir d'un flux d'octets dans un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié. - Flux à lire. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'option de détection de la marque d'ordre d'octet spécifiée. - Flux à lire. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères spécifié. - Flux à lire. - Encodage des caractères à utiliser. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères et l'option de détection de la marque d'ordre d'octet spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - - ne prend pas en charge la lecture. - - ou a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, avec l'encodage de caractères, l'option de détection de la marque d'ordre d'octet et la taille de mémoire tampon spécifiés. - Flux à lire. - Encodage des caractères à utiliser. - Indique s'il faut rechercher les marques d'ordre des octets au début du fichier. - Taille minimale de la mémoire tampon. - Le flux ne prend pas en charge la lecture. - - ou a la valeur null. - - est inférieur ou égal à zéro. - - - Initialise une nouvelle instance de la classe pour le flux spécifié en fonction de l'encodage de caractères, de l'option de détection de la marque d'ordre d'octet et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Flux à lire. - Encodage des caractères à utiliser. - true pour rechercher les marques d'ordre d'octet au début du fichier ; sinon, false. - Taille minimale de la mémoire tampon. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - - Retourne le flux sous-jacent. - Flux sous-jacent. - 2 - - - Obtient l'encodage de caractères actuel utilisé par l'objet actuel. - Encodage des caractères actuel utilisé par le lecteur en cours.La valeur peut être différente après le premier appel à toute méthode de , car la détection automatique de l'encodage n'est effectuée qu'au premier appel à une méthode . - 2 - - - Efface la mémoire tampon interne. - 2 - - - Ferme le flux sous-jacent, libère les ressources non managées utilisées par l'élément et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Obtient une valeur qui indique si la position actuelle dans le flux est à la fin du flux. - true si la position actuelle dans le flux est à la fin du flux ; sinon, false. - Le flux sous-jacent a été supprimé. - 1 - - - Objet autour d'un flux vide. - 1 - - - Retourne le caractère disponible suivant, mais ne le consomme pas. - Entier représentant le caractère suivant à lire, ou -1 s'il n'y a pas de caractère à lire ou si le flux ne prend pas en charge la recherche. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère. - Caractère suivant du flux d'entrée, représenté sous la forme d'un objet , ou -1 s'il n'y a plus de caractère disponible. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié. - Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue.Le nombre sera inférieur ou égal à la valeur du paramètre , selon que les données sont, ou non, disponibles dans le flux. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Index de auquel commencer l'écriture. - Nombre maximal de caractères à lire. - La longueur de la mémoire tampon moins est inférieure à . - - a la valeur null. - - ou est négatif. - Une erreur d'E/S, telle que la fermeture du flux, se produit. - 1 - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode en cours se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du flux actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus ou non. - Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre et () sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S s'est produite. - - - Lit un nombre maximal spécifié de caractères dans le flux actuel de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur du résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du flux a été atteinte. - Quand cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source actuelle. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du flux est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode se termine. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères du flux actuel et retourne les données sous forme de chaîne. - Ligne suivante du flux d'entrée, ou null si la fin du flux d'entrée est atteinte. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit une ligne de caractères de manière asynchrone dans le flux actuel et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante du flux, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du flux. - Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin.Si la position actuelle est à la fin du flux, retourne une chaîne vide (""). - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Une erreur d'E/S se produit. - 1 - - - Lit tous les caractères entre la position actuelle et la fin du flux de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères allant de la position actuelle à la fin du flux. - Le nombre de caractères est supérieur à . - Le flux a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour écrire les caractères dans un flux selon un encodage particulier.Pour parcourir le code source de .NET Framework pour ce type, consultez la Source de référence. - 1 - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage UTF-8 et de la taille de la mémoire tampon par défaut. - Le flux dans lequel écrire. - - n'est pas accessible en écriture. - - a la valeur null. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage spécifié et de la taille de mémoire tampon par défaut. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - - ou est null. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Initialise une nouvelle instance de la classe pour le flux spécifié, à l'aide de l'encodage et de la taille de mémoire tampon spécifiés, et permet éventuellement de laisser le flux ouvert. - Le flux dans lequel écrire. - Encodage des caractères à utiliser. - Taille de la mémoire tampon en octets. - true pour maintenir le flux ouvert après avoir supprimé l'objet  ; sinon, false. - - ou est null. - - est négatif. - - n'est pas accessible en écriture. - - - Obtient ou définit une valeur indiquant si vide sa mémoire tampon vers le flux sous-jacent après chaque appel à . - true pour forcer à vider sa mémoire tampon ; sinon, false. - 1 - - - Obtient le flux sous-jacent qui sert d'interface avec un magasin de stockage. - Flux dans lequel ce StreamWriter écrit. - 2 - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - - - Obtient le dans lequel la sortie est écrite. - - spécifié dans le constructeur pour l'instance actuelle, ou si aucun encodage n'est spécifié. - 2 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon dans le flux sous-jacent. - Le writer actuel est fermé. - Une erreur d'E/S s'est produite. - L'encodage actuel ne prend pas en charge l'affichage de la moitié d'une paire de substitution Unicode. - 1 - - - Efface toutes les mémoires tampons pour ce flux de manière asynchrone et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le flux a été supprimé. - - - Fournit un StreamWriter sans magasin de sauvegarde dans lequel il est possible d'écrire, mais qu'il est impossible de lire. - 1 - - - Écrit un caractère dans le flux. - Caractère à écrire dans le flux. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire.Si est null, rien n'est écrit. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit un sous-tableau de caractères dans le flux. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Une erreur d'E/S se produit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - 1 - - - Écrit une chaîne dans le flux. - Chaîne à écrire dans le flux.Si a la valeur null, rien n'est écrit. - - a la valeur true ou la mémoire tampon de est saturée, et le writer actuel est fermé. - - a la valeur true ou la mémoire tampon de est saturée, et le contenu de la mémoire tampon ne peut pas être écrit dans le flux de taille fixe sous-jacent, car se trouve à la fin du flux. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères contenant les données à écrire. - Position du caractère dans la mémoire où commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire dans le flux.Si est null, rien n'est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un terminateur de ligne dans le flux de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans le flux un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon où la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'un terminateur de ligne de façon asynchrone dans le flux. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de flux est supprimé. - Le writer du flux est actuellement utilisé par une opération d'écriture précédente. - - - Implémente qui lit une chaîne. - 2 - - - Initialise une nouvelle instance de la classe qui lit la chaîne spécifiée. - Chaîne à laquelle doit être initialisé. - Le paramètre est null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Retourne le prochain caractère disponible, mais ne le consomme pas. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le flux ne prend pas en charge la recherche. - Le lecteur actuel est fermé. - 2 - - - Lit le caractère suivant dans la chaîne d'entrée et avance sa position d'un caractère. - Caractère suivant de la chaîne sous-jacente, ou -1 si plus aucun caractère n'est disponible. - Le lecteur actuel est fermé. - 2 - - - Lit un bloc de caractères dans la chaîne d'entrée et avance la position du caractère de . - Nombre total de caractères lus dans la mémoire tampon.Cela peut être inférieur au nombre de caractères demandé si ce nombre n'est pas actuellement disponible, ou égal à zéro si la fin de la chaîne sous-jacente a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Index de début dans la mémoire tampon. - Nombre de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - Le lecteur actuel est fermé. - 2 - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir de la chaîne actuelle de manière asynchrone, et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin de la chaîne a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin de la chaîne est atteinte avant que le nombre de caractères spécifié soit écrit dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Ligne suivante dans la chaîne actuelle ou null si la fin de la chaîne est atteinte. - Le lecteur actuel est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - 2 - - - Lit une ligne de caractères de manière asynchrone à partir de la chaîne en cours et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de chaîne, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne, puis les retourne sous la forme d'une chaîne unique. - Contenu à partir de la position actuelle jusqu'à la fin du flux sous-jacent. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le lecteur actuel est fermé. - 2 - - - Lit tous les caractères entre la position actuelle et la fin de la chaîne de manière asynchrone, puis les retourne sous la forme d'une chaîne unique. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin de la chaîne. - Le nombre de caractères est supérieur à . - Le lecteur de chaîne a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Implémente pour l'écriture d'informations dans une chaîne.Les informations sont stockées dans un sous-jacent. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le contrôle de format spécifié. - Objet qui contrôle la mise en forme. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié. - StringBuilder dans lequel écrire. - - a la valeur null. - - - Initialise une nouvelle instance de la classe qui écrit dans le spécifié et possède le fournisseur de formats donné. - StringBuilder dans lequel écrire. - Objet qui contrôle la mise en forme. - - a la valeur null. - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. - - - Obtient le dans lequel la sortie est écrite. - Encoding dans lequel la sortie est écrite. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur le périphérique sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - - - Retourne le sous-jacent. - StringBuilder sous-jacent. - 2 - - - Retourne une chaîne contenant les caractères écrits jusqu'ici dans le StringWriter en cours. - Chaîne contenant les caractères écrits dans le StringWriter en cours. - 2 - - - Écrit un caractère dans la chaîne. - Caractère à écrire. - Le writer est fermé. - 2 - - - Écrit un sous-tableau de caractères dans la chaîne. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - ou est négatif. - ( + )> .Length. - Le writer est fermé. - 2 - - - Écrit une chaîne dans la chaîne actuelle. - Chaîne à écrire. - Le writer est fermé. - 2 - - - Écrit un caractère dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères dans la chaîne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne dans la chaîne actuelle de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si est null, rien n'est écrit dans le flux de texte. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit dans la chaîne un caractère suivi d'un terminateur de ligne de façon asynchrone. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans la chaîne. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'un terminateur de ligne de façon asynchrone dans la chaîne. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position dans la mémoire tampon à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie par un terminateur de ligne de façon asynchrone dans la chaîne actuelle. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul le terminateur de ligne est écrit. - Le writer de chaîne est supprimé. - Le writer de chaîne est actuellement utilisé par une opération d'écriture précédente. - - - Représente un lecteur capable de lire une série séquentielle de caractères. - 2 - - - Initialise une nouvelle instance de la classe . - - - Libère toutes les ressources utilisées par . - - - Libère les ressources non managées utilisées par l'objet et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - Fournit un TextReader sans données à lire. - 1 - - - Lit le caractère suivant sans modifier l'état du lecteur ou la source du caractère.Retourne le prochain caractère disponible sans le lire réellement à partir du flux lecteur. - Entier représentant le prochain caractère à lire, ou -1 si plus aucun caractère n'est disponible ou si le lecteur ne prend pas en charge la recherche. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit le caractère suivant à partir du lecteur de texte et avance la position d'un caractère. - Caractère suivant du lecteur de texte ou -1 s'il n'y a plus de caractères disponibles.L'implémentation par défaut retourne -1. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit un nombre maximal spécifié de caractères à partir du lecteur actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon les données disponibles dans le lecteur.Cette méthode retourne zéro si elle est appelée alors qu'il ne reste aucun caractère à lire. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du lecteur est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode est retournée. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit un nombre maximal spécifié de caractères à partir du lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Nombre de caractères lus.Le nombre sera inférieur ou égal à , selon que tous les caractères d'entrée ont été lus. - Lorsque cette méthode est retournée, ce paramètre contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + -1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire. - - a la valeur null. - La longueur de la mémoire tampon moins est inférieure à . - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 2 - - - Lit de façon asynchrone un nombre maximal de caractères spécifié dans le lecteur de texte actuel et écrit les données dans une mémoire tampon, en commençant à l'index spécifié. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient le nombre total d'octets lus dans la mémoire tampon.La valeur de résultat peut être inférieure au nombre d'octets demandés si le nombre d'octets actuellement disponibles est inférieur au nombre demandé, ou elle peut avoir la valeur 0 (zéro) si la fin du texte a été atteinte. - Lorsque cette méthode est retournée, contient le tableau de caractères spécifié dont les valeurs comprises entre et ( + - 1) sont remplacées par les caractères lus dans la source en cours. - Position dans à partir de laquelle commencer l'écriture. - Nombre maximal de caractères à lire.Si la fin du texte est atteinte avant que le nombre de caractères spécifié soit lu dans la mémoire tampon, la méthode en cours est retournée. - - a la valeur null. - - ou est négatif. - La somme de et de est supérieure à la longueur de la mémoire tampon. - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit une ligne de caractères à partir du lecteur de texte et retourne les données sous forme de chaîne. - La ligne suivante du lecteur ou null si tous les caractères ont été lus. - Une erreur d'E/S se produit. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - - est fermé. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit une ligne de caractères de manière asynchrone et retourne les données sous forme de chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient la ligne suivante issue du lecteur de texte, ou a la valeur null si tous les caractères ont été lus. - Le nombre de caractères contenus dans la ligne suivante est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte, puis les retourne sous forme d'une chaîne. - Chaîne contenant tous les caractères entre la position actuelle et la fin du lecteur de texte. - Une erreur d'E/S se produit. - - est fermé. - La mémoire disponible est insuffisante pour allouer une mémoire tampon pour la chaîne retournée. - Le nombre de caractères contenus dans la ligne suivante est supérieur à - 1 - - - Lit tous les caractères entre la position actuelle et la fin du lecteur de texte de manière asynchrone, puis les retourne sous la forme d'une chaîne. - Tâche qui représente l'opération de lecture asynchrone.La valeur du paramètre contient une chaîne composée des caractères de la position actuelle jusqu'à la fin du flux du lecteur de texte. - Le nombre de caractères est supérieur à . - Le lecteur de texte a été supprimé. - Lecteur est en cours d'utilisation par une opération de lecture précédente. - - - Représente un writer capable d'écrire une série de caractères séquentiels.Cette classe est abstraite. - 2 - - - Initialise une nouvelle instance de la classe . - - - Initialise une nouvelle instance de la classe avec le fournisseur de format spécifié. - Objet qui contrôle la mise en forme. - - - Stocke les caractères de saut de ligne utilisés pour ce TextWriter. - - - Libère toutes les ressources utilisées par l'objet . - - - Libère les ressources non managées utilisées par et libère éventuellement les ressources managées. - true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. - - - En cas de substitution dans une classe dérivée, retourne l'encodage de caractères dans lequel la sortie est écrite. - Encodage de caractères dans lequel la sortie est écrite. - 1 - - - Efface toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - 1 - - - Efface de façon asynchrone toutes les mémoires tampons pour le writer actuel et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent. - Tâche qui représente l'opération de vidage asynchrone. - Le writer de texte est supprimé. - Le writer est actuellement utilisé par une opération d'écriture précédente. - - - Obtient un objet qui contrôle la mise en forme. - Objet pour une culture spécifique, ou mise en forme de la culture actuelle si aucune autre culture n'est spécifiée. - 2 - - - Obtient ou définit la chaîne de marque de fin de ligne utilisée pour le TextWriter actuel. - Chaîne de marque de fin de ligne pour le TextWriter actuel. - 2 - - - Fournit un élément TextWriter sans magasin de stockage dans lequel il est possible d'écrire, mais pas de lire. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères dans la chaîne ou le flux de texte. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet dans la chaîne ou le flux de texte en appelant la méthode ToString sur cet objet. - Objet à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne dans la chaîne ou le flux de texte. - Chaîne à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - - ou a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si a la valeur null, rien n'est écrit. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si a la valeur null, rien n'est écrit dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une marque de fin de ligne dans la chaîne ou le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur Boolean suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - La valeur Boolean à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un caractère suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Caractère à écrire dans le flux de texte. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Tableau de caractères dans lequel sont lues des données. - Dans , position de caractère à laquelle commencer la lecture des données. - Nombre maximal de caractères à écrire. - La longueur de la mémoire tampon moins est inférieure à . - Le paramètre a la valeur null. - - ou est négatif. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur décimale suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur décimale à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 8 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un objet en appelant la méthode ToString sur cet objet, suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Objet à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'une valeur à virgule flottante de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Valeur à virgule flottante de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Chaîne à écrire.Si a la valeur null, seule la marque de fin de ligne est écrite. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à un). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne dans la chaîne ou le flux de texte, en utilisant la même sémantique que la méthode . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à deux). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Premier objet à mettre en forme et à écrire. - Deuxième objet à mettre en forme et à écrire. - Troisième objet à mettre en forme et à écrire. - - a la valeur null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de format est inférieur à 0 (zéro) ou supérieur ou égal au nombre d'objets à mettre en forme (qui, pour cette surcharge de méthode, s'élève à trois). - 1 - - - Écrit une chaîne mise en forme et une nouvelle ligne, en utilisant la même sémantique que . - Chaîne de format composite (consultez la section Notes). - Tableau d'objets contenant aucun, un ou plusieurs objets à mettre en forme et à écrire. - Une chaîne ou un objet est passé en tant que null. - - est fermé. - Une erreur d'E/S se produit. - - n'est pas une chaîne de format composite.ou L'index d'un élément de mise en forme est inférieur à 0 (zéro), ou supérieur ou égal à la longueur du tableau . - 1 - - - Écrit la représentation textuelle d'un entier non signé de 4 octets suivie d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 4 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit la représentation textuelle d'un entier non signé de 8 octets suivi d'une marque de fin de ligne dans la chaîne ou le flux de texte. - Entier non signé de 8 octets à écrire. - - est fermé. - Une erreur d'E/S se produit. - 1 - - - Écrit une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un caractère suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Caractère à écrire dans le flux de texte. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à écrire dans le flux de texte.Si le tableau de caractères a la valeur null, seul la marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit un sous-tableau de caractères suivi d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Tableau de caractères à partir duquel les données doivent être écrites. - Position du caractère dans la mémoire tampon à laquelle commencer la récupération des données. - Nombre de caractères à écrire. - - a la valeur null. - - plus est supérieur à la longueur de la mémoire tampon. - - ou est négatif. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - Écrit une chaîne suivie d'une marque de fin de ligne de façon asynchrone dans la chaîne ou le flux de texte. - Tâche qui représente l'opération d'écriture asynchrone. - Chaîne à écrire.Si la valeur est null, seul une marque de fin de ligne est écrite. - Le writer de texte est supprimé. - Le writer de texte est actuellement utilisé par une opération d'écriture précédente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml deleted file mode 100644 index 46070bec..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/it/System.IO.xml +++ /dev/null @@ -1,2123 +0,0 @@ - - - - System.IO - - - - Legge i tipi di dati primitivi come valori binari in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe in base al flusso specificato e usando la codifica UTF-8. - Flusso di input. - Il flusso non supporta la lettura, è null o è già chiuso. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e del flusso specificata. - Flusso di input. - Codifica dei caratteri da usare. - Il flusso non supporta la lettura, è null o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica dei caratteri e di flusso specificati. Facoltativamente mantiene aperto il flusso. - Flusso di input. - Codifica dei caratteri da usare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la lettura, è null o è già chiuso. - - o è null. - - - Espone l'accesso al flusso sottostante dell'oggetto . - Flusso sottostante associato all'oggetto BinaryReader. - 2 - - - Rilascia tutte le risorse usate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Inserisce nel buffer interno il numero specificato di byte letti dal flusso. - Numero di byte da leggere. - È stata raggiunta la fine del flusso prima che fosse possibile leggere . - Si è verificato un errore di I/O. - I richiesti sono superiori alla dimensione del buffer interno. - - - Restituisce il successivo carattere disponibile senza spostare in avanti la posizione del byte o del carattere. - Carattere successivo disponibile oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - Impossibile decodificare il carattere corrente nel buffer di caratteri interno tramite l'oggetto selezionato per il flusso. - 2 - - - Legge i caratteri dal flusso sottostante e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico che il flusso sta leggendo. - Carattere successivo dal flusso di input oppure -1 se non vi sono caratteri disponibili. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Legge il numero specificato di byte dal flusso, a partire da un punto specificato nella matrice di byte. - Numero di byte letti nell'oggetto .Può essere minore del numero di byte richiesti, se tale quantità di byte non è disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di byte da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di caratteri dal flusso, a partire da un punto specificato nella matrice di caratteri. - Numero complessivo di caratteri letti nel buffer.Può essere minore del numero di caratteri richiesti, se tale quantità di caratteri non è attualmente disponibile, oppure zero, se è stata raggiunta la fine del flusso. - Buffer in cui leggere i dati. - Punto di partenza nel buffer dal quale avviare la lettura nel buffer. - Numero di caratteri da leggere. - La lunghezza del buffer meno è minore di . -oppure-Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - - è null. - Il valore di o è negativo. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero a 32 bit in formato compresso. - Intero a 32 bit in formato compresso. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - Flusso danneggiato. - - - Legge un valore Boolean dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - true se il byte è diverso da zero; in caso contrario, false. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il byte successivo dal flusso corrente e sposta in avanti di 1 byte la posizione corrente del flusso. - Byte successivo letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge il numero specificato di byte dal flusso corrente in una matrice di byte e sposta in avanti la posizione corrente in base a tale numero di byte. - Matrice di byte contenente dati letti dal flusso sottostante.Può essere minore del numero di byte necessari se viene raggiunta la fine del flusso. - Numero di byte da leggere.Questo valore deve essere 0 o un numero non negativo; in caso contrario, si verificherà un'eccezione. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è negativo. - 2 - - - Legge il carattere successivo dal flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Carattere letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - È stato letto un carattere surrogato. - 2 - - - Legge il numero specificato di caratteri dal flusso corrente, restituisce i dati in una matrice di caratteri e sposta in avanti la posizione corrente secondo il valore Encoding usato e il carattere specifico letto dal flusso. - Matrice di caratteri contenente dati letti dal flusso sottostante.Può essere minore del numero di caratteri necessari se viene raggiunta la fine del flusso. - Numero di caratteri da leggere. - Il numero dei caratteri decodificati da leggere è maggiore di .Questo caso può verificarsi se un decodificatore Unicode restituisce caratteri di fallback o una coppia di surrogati. - Il flusso è chiuso. - Si è verificato un errore di I/O. - - è negativo. - 2 - - - Legge un valore decimale dal flusso corrente e sposta in avanti di sedici byte la posizione corrente del flusso. - Valore decimale letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione corrente del flusso. - Valore a virgola mobile a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 2 byte dal flusso corrente e sposta in avanti di 2 byte la posizione corrente del flusso. - Intero con segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Intero con segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero con segno a 8 byte dal flusso corrente e sposta in avanti di 8 byte la posizione del flusso. - Intero con segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un byte con segno dal flusso corrente e sposta in avanti di un byte la posizione corrente del flusso. - Byte con segno letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un valore a virgola mobile a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione corrente del flusso. - Valore a virgola mobile a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge una stringa dal flusso corrente.La stringa ha un prefisso di lunghezza e viene codificata come intero, 7 bit alla volta. - Stringa da leggere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 2 byte dal flusso corrente usando la codifica little-endian e sposta in avanti di due byte la posizione del flusso. - Intero senza segno a 2 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 4 byte dal flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero senza segno a 4 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 2 - - - Legge un intero senza segno a 8 byte dal flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero senza segno a 8 byte letto dal flusso corrente. - È stata raggiunta la fine del flusso. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 2 - - - Scrive i tipi primitivi in codice binario in un flusso e supporta la scrittura di stringhe in una determinata codifica. - 2 - - - Inizializza una nuova istanza della classe che scrive in un flusso. - - - Inizializza una nuova istanza della classe in base alla codifica using UTF-8 e di flusso specificata. - Flusso di output. - Il flusso non supporta la scrittura o è già chiuso. - - è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. - Flusso di output. - Codifica dei caratteri da utilizzare. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Inizializza una nuova istanza della classe in base alla codifica caratteri e di flusso specificata. Facoltativamente mantiene aperto il flusso. - Flusso di output. - Codifica dei caratteri da utilizzare. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - Il flusso non supporta la scrittura o è già chiuso. - - o è null. - - - Ottiene il flusso sottostante dell'oggetto . - Flusso sottostante associato a BinaryWriter. - 1 - - - Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Specifica un oggetto privo di archivio di backup. - 1 - - - Contiene il flusso principale. - - - Imposta la posizione all'interno del flusso corrente. - Posizione all'interno del flusso corrente. - Offset dei byte relativo a . - Campo di che indica il punto di riferimento dal quale ottenere la nuova posizione. - Il puntatore a file è stato spostato in un percorso non valido. - Il valore di non è valido. - 1 - - - Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true. - Valore Boolean da scrivere (0 o 1). - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una matrice di byte nel flusso sottostante. - Matrice di caratteri che contiene i dati da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è null. - 1 - - - Scrive un'area di una matrice di byte nel flusso corrente. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale nel parametro da cui iniziare la scrittura. - Numero di byte da scrivere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Carattere Unicode non surrogato da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - - è un carattere surrogato singolo. - 1 - - - Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - - è null. - Il flusso è chiuso. - Si è verificato un errore di I/O. - 1 - - - Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding utilizzato e i caratteri specifici scritti nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Punto iniziale in dal quale avviare la scrittura. - Numero di caratteri da inserire. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore decimale nel flusso corrente e sposta in avanti di 16 byte la posizione del flusso. - Valore decimale da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Valore a virgola mobile a otto byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte con segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte con segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte con segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso. - Byte con segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Valore a virgola mobile a quattro byte da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto e sposta in avanti la posizione corrente del flusso secondo la codifica utilizzata e i caratteri specifici scritti nel flusso. - Valore da scrivere. - Si è verificato un errore di I/O. - - è null. - Il flusso è chiuso. - 1 - - - Scrive un intero a due byte senza segno nel flusso corrente e sposta in avanti di due byte la posizione del flusso. - Intero a due byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a quattro byte senza segno nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso. - Intero a quattro byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Scrive un intero a otto byte senza segno nel flusso corrente e sposta in avanti di otto byte la posizione del flusso. - Intero a otto byte senza segno da scrivere. - Si è verificato un errore di I/O. - Il flusso è chiuso. - 1 - - - Inserisce un valore intero a 32 bit in un formato compresso. - Intero da 32 bit da scrivere. - È stata raggiunta la fine del flusso. - Il flusso è chiuso. - Il flusso è chiuso. - - - Eccezione generata durante il tentativo di leggere oltre la fine di un flusso. - 2 - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su un messaggio fornito dal sistema e il relativo HRESULT impostato su COR_E_ENDOFSTREAM. - - - Inizializza una nuova istanza della classe con la relativa stringa di messaggio impostata su e HRESULT impostato su COR_E_ENDOFSTREAM. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - - - Consente l'inizializzazione di una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. - Stringa nella quale è descritto l'errore.Il contenuto di deve essere facilmente comprensibile.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Eccezione generata se un flusso di dati è in un formato non valido. - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con un messaggio di errore specificato. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - - - Inizializza una nuova istanza della classe con un riferimento all'eccezione interna che è la causa dell'eccezione. - Messaggio di errore nel quale viene indicato il motivo dell’eccezione - Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. - - - Crea un flusso il cui archivio di backup è costituito dalla memoria.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata su zero. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata. - Matrice di byte senza segno da cui creare il flusso corrente. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla matrice di byte specificata, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - - Inizializza una nuova istanza non ridimensionabile della classe in base alla area specificata (indice) di una matrice di byte. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - - è null. - - o è minore di zero. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza non ridimensionabile della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - - è null. - - o è un valore negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe in base all'area specificata di una matrice di byte, con la proprietà impostata secondo quanto specificato e la possibilità di chiamare il metodo impostato nel modo specificato. - Matrice di byte senza segno da cui creare il flusso. - Indice in in corrispondenza del quale inizia il flusso. - Lunghezza del flusso in byte. - Impostazione della proprietà , che determina se il flusso supporta la scrittura. - true per abilitare il metodo , che restituisce la matrice di byte senza segno da cui è stato creato il flusso; in caso contrario, false. - - è null. - Il valore di o è negativo. - La lunghezza del buffer meno è minore di . - - - Inizializza una nuova istanza della classe con una capacità espandibile inizializzata secondo quanto specificato. - Dimensione iniziale in byte della matrice interna. - - è negativo. - - - Ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso è aperto. - 2 - - - Ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 2 - - - Ottiene o imposta il numero di byte allocati per questo flusso. - Lunghezza della parte usabile del buffer per il flusso. - È stata impostata una capacità negativa o minore della lunghezza corrente del flusso. - Il flusso corrente è chiuso. - set è stato richiamato su un flusso del quale non è possibile modificare la capacità. - 2 - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando le dimensione del buffer specificate e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero. - Token da monitorare per le richieste di annullamento. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia le risorse non gestite usate dalla classe e facoltativamente le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Esegue l'override del metodo in modo che non venga effettuata alcuna operazione. - 2 - - - Rimuove in modo asincrono tutti i buffer per questo flusso e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento. - Il flusso è stato eliminato. - - - Ottiene la lunghezza in byte del flusso. - Lunghezza del flusso in byte. - Il flusso è chiuso. - 2 - - - Ottiene o imposta la posizione corrente all'interno del flusso. - Posizione corrente all'interno del flusso. - La posizione è impostata su un valore negativo o maggiore di . - Il flusso è chiuso. - 2 - - - Legge un blocco di byte dal flusso corrente e scrive i dati in un buffer. - Numero complessivo di byte scritti nel buffer.Può essere minore del numero di byte richiesti se tale numero di byte non è al momento disponibile o pari a zero se è stata raggiunta la fine del flusso prima della lettura di qualsiasi byte. - Quando questo metodo viene restituito, contiene la matrice di byte specificata in cui i valori tra e ( + - 1) sono sostituiti dai caratteri letti dal flusso corrente. - Offset di byte in base zero in da cui iniziare l'archiviazione dei dati dal flusso corrente. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - - sottratto alla lunghezza del buffer è minore di . - L'istanza del flusso corrente è chiusa. - 2 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso corrente. - Cast di byte su un oggetto o -1 se è stata raggiunta la fine del flusso. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la posizione all'interno del flusso corrente sul valore specificato. - Nuova posizione all'interno del flusso, calcolata combinando il punto di riferimento iniziale e l'offset. - Nuova posizione all'interno del flusso.È relativa al parametro e può essere positiva o negativa. - Valore di tipo , che funge da punto di riferimento per la ricerca. - La ricerca viene tentata prima dell'inizio del flusso. - - è maggiore di . - Il valore di non è valido. -oppure- causato da un overflow aritmetico. - L'istanza del flusso corrente è chiusa. - 2 - - - Imposta la lunghezza del flusso corrente sul valore specificato. - Valore su cui impostare la lunghezza. - Il flusso corrente non è ridimensionabile e il parametro è maggiore della capacità corrente.-oppure- Il flusso corrente non supporta la scrittura. - - è negativo o maggiore della lunghezza massima dell'oggetto , in cui la lunghezza massima corrisponde a ( - origine) e l'origine corrisponde all'indice nel buffer sottostante in corrispondenza del quale inizia il flusso. - 2 - - - Scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà . - Nuova matrice di byte. - 2 - - - Restituisce la matrice di byte senza segno da cui è stato creato questo flusso.Il valore restituito indica se la conversione è riuscita. - true se la conversione riesce; in caso contrario, false. - Segmento di matrice di byte da cui è stato creato questo flusso. - - - Scrive un blocco di byte nel flusso corrente usando dati letti da un buffer. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero massimo di byte da scrivere. - - è null. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente, rispetto al numero di byte specificati in , è più vicina alla fine del flusso e non è possibile modificare la capacità. - - sottratto alla lunghezza del buffer è minore di . - - o è un valore negativo. - Si è verificato un errore di I/O. - L'istanza del flusso corrente è chiusa. - 2 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente all'interno del flusso corrente. - Byte da scrivere. - Il flusso non supporta la scrittura.Per ulteriori informazioni, vedere .-oppure- La posizione corrente è alla fine del flusso e non è possibile modificare la capacità. - Il flusso corrente è chiuso. - 2 - - - Scrive l'intero contenuto del flusso di memoria in un altro flusso. - Flusso in cui scrivere il flusso di memoria. - - è null. - Il flusso corrente o di destinazione è chiuso. - 2 - - - Specifica la posizione in un flusso da utilizzare per le ricerche. - 2 - - - Specifica l'inizio di un flusso. - - - Specifica la posizione corrente all'interno di un flusso. - - - Specifica la fine di un flusso. - - - Fornisce una visualizzazione generica di una sequenza di byte.Questa è una classe abstract.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 2 - - - Inizializza una nuova istanza della classe . - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la lettura. - true se il flusso supporta la lettura; in caso contrario, false. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la ricerca. - true se il flusso supporta la ricerca; in caso contrario, false. - 1 - - - Ottiene un valore che determina se il flusso corrente prevede il timeout. - Valore che determina se il flusso corrente prevede il timeout. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se il flusso corrente supporta la scrittura. - true se il flusso supporta la scrittura; in caso contrario, false. - 1 - - - Legge i byte dal flusso corrente e li scrive in un altro flusso. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente non supporta la lettura.-oppure- non supporta la scrittura. - Il flusso corrente o sono stati chiusi prima che venisse chiamato il metodo . - Si è verificato un errore di I/O. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - - è null. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento. - Attività che rappresenta l'operazione di copia asincrona. - Flusso in cui verrà copiato il contenuto del flusso corrente. - Dimensione del buffer, in byte.Il valore deve essere maggiore di zero.La dimensione predefinita è 81920. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - - è un valore negativo o zero. - Il flusso corrente o il flusso di destinazione viene eliminato. - Il flusso corrente non supporta la lettura, o il flusso di destinazione non supporta la scrittura. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Quando ne viene eseguito l'override in una classe derivata, cancella tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Si è verificato un errore di I/O. - 2 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Cancella in modo asincrono i dati di tutti i buffer del flusso, determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scaricamento asincrona. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - Il flusso è stato eliminato. - - - Quando ne viene eseguito l'override in una classe derivata, ottiene la lunghezza in byte del flusso. - Valore long che rappresenta la lunghezza del flusso in byte. - Una classe derivata da Stream non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Oggetto Stream privo di archivio di backup. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, ottiene o imposta la posizione all'interno del flusso corrente. - Posizione corrente all'interno del flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti. - Numero complessivo di byte letti nel buffer.È possibile che questo numero sia inferiore a quello dei byte richiesti se la quantità di byte disponibili è minore oppure che corrisponda a zero (0) se è stata raggiunta la fine del flusso. - Matrice di byte.Quando questo metodo viene restituito, il buffer contiene la matrice di byte specificata con i valori compresi tra e ( + - 1) sostituiti con i byte letti dall'origine corrente. - Offset dei byte in base zero in in corrispondenza del quale iniziare l'archiviazione dei dati letti dal flusso corrente. - Numero massimo di byte da leggere dal flusso corrente. - La somma di e è maggiore della lunghezza del buffer. - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte letti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Buffer in cui scrivere i dati. - Offset dei byte in da cui iniziare la scrittura dei dati dal flusso. - Numero massimo di byte da leggere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la lettura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. - Cast di byte senza segno in un parametro Int32 oppure -1 se si trova alla fine del flusso. - Il flusso non supporta la lettura. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la lettura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la posizione all'interno del flusso corrente. - Nuova posizione all'interno del flusso corrente. - Offset dei byte rispetto al parametro . - Valore di tipo che indica il punto di riferimento usato per ottenere la nuova posizione. - Si è verificato un errore di I/O. - Il flusso non supporta la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 1 - - - Quando ne viene eseguito l'override in una classe derivata, imposta la lunghezza del flusso corrente. - Lunghezza desiderata del flusso corrente in byte. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura e la ricerca, come se il flusso fosse stato costruito da un pipe o da un output di console. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti. - Matrice di byte.Questo metodo copia i byte da nel flusso corrente. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso corrente. - Numero di byte da scrivere nel flusso corrente. - La somma di  e  è maggiore della lunghezza del buffer. - - è null. - - o  è negativo. - Si è verificato un errore dei / o, ad esempio possibile trovare il file specificato. - Il flusso non supporta la scrittura. - - è stato chiamato dopo la chiusura del flusso. - 1 - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente in base al numero di byte scritti e monitora le richieste di annullamento. - Attività che rappresenta l'operazione di scrittura asincrona. - Buffer da cui scrivere i dati. - Offset dei byte in base zero in da cui iniziare la copia dei byte nel flusso. - Numero massimo di byte da scrivere. - Token da monitorare per le richieste di annullamento.Il valore predefinito è . - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso non supporta la scrittura. - Il flusso è stato eliminato. - Il flusso è al momento utilizzato da un'operazione di scrittura precedente. - - - Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. - Byte da scrivere nel flusso. - Si è verificato un errore di I/O. - Il flusso non supporta la scrittura o è già chiuso. - Sono stati chiamati dei metodi dopo la chiusura del flusso. - 2 - - - Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Valore in millisecondi che determina per quanto tempo il flusso tenterà la scrittura prima del timeout. - Il metodo genera sempre un'eccezione . - 2 - - - Implementa un oggetto che legge i caratteri da un flusso di byte in una particolare codifica.Per esaminare il codice sorgente di .NET Framework per questo tipo, vedere il Reference Source. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato. - Flusso da leggere. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con l'opzione specificata per il rilevamento dei byte order mark. - Flusso da leggere. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri specificata. - Flusso da leggere. - Codifica dei caratteri da usare. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri e l'opzione per il rilevamento dei byte order mark specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - - non supporta la lettura. - - o è null. - - - Inizializza una nuova istanza della classe per il flusso specificato, con la codifica dei caratteri, l'opzione per il rilevamento dei byte order mark e le dimensioni del buffer specificati. - Flusso da leggere. - Codifica dei caratteri da usare. - Indica se cercare i byte order mark all'inizio del file. - Dimensione minima del buffer. - Il flusso non supporta la lettura. - - o è null. - - è minore o uguale a zero. - - - Inizializza una nuova istanza della classe per il flusso specificato in base alla codifica caratteri, all'opzione per il rilevamento dei byte order mark e alle dimensioni del buffer specificati. Facoltativamente mantiene aperto il flusso. - Flusso da leggere. - Codifica dei caratteri da usare. - true per cercare i byte order mark all'inizio del file; in caso contrario, false. - Dimensione minima del buffer. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - - Restituisce il flusso sottostante. - Flusso sottostante. - 2 - - - Ottiene la codifica caratteri corrente usata dall'oggetto corrente. - Codifica caratteri usata dal lettore corrente.Il valore può essere diverso dopo la prima chiamata a un metodo di , in quanto il rilevamento automatico della codifica non è completo fino alla prima chiamata a un metodo . - 2 - - - Cancella il buffer interno. - 2 - - - Chiude il flusso sottostante, rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Ottiene un valore che indica se la posizione corrente del flusso è alla fine del flusso. - true se la posizione corrente del flusso è alla fine del flusso; in caso contrario, false. - Il flusso sottostante è stato eliminato. - 1 - - - Oggetto che include un flusso vuoto. - 1 - - - Restituisce il carattere successivo disponibile senza usarlo. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono presenti caratteri da leggere o se il flusso non supporta la ricerca. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal flusso di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo dal flusso di input rappresentato come oggetto oppure -1 se non sono disponibili altri caratteri. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, iniziando dall'indice specificato. - Numero di caratteri letti oppure 0 se alla fine del flusso non è stato letto alcun dato.Il numero sarà minore o uguale al parametro , a seconda che i dati siano disponibili o meno all'interno del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Indice di da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - La lunghezza del buffer meno è minore di . - - è null. - Il valore di o è negativo. - Si è verificato un errore di I/O, come la chiusura del flusso. - 1 - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e () sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - - - Legge in modo asincrono un numero massimo specificato di caratteri dal flusso corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a 0 (zero) se è stata raggiunta la fine del flusso. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del flusso prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal flusso corrente e restituisce i dati come stringa. - Riga successiva del flusso di input oppure null se viene raggiunta la fine del flusso di input. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge una riga di caratteri in modo asincrono dal flusso corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del flusso oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso. - Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota (""). - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Si è verificato un errore di I/O. - 1 - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso in modo asincrono e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e la fine del flusso. - Il numero di caratteri è maggiore di . - Il flusso è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto che scrive i caratteri in un flusso con una particolare codifica.Per esaminare il codice sorgente .NET Framework per questo tipo, vedere Origine riferimento. - 1 - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica UTF-8 e le dimensioni del buffer predefinite. - Flusso in cui scrivere. - - non è modificabile. - - è null. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - - o è null. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica caratteri e le dimensioni del buffer specificate. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - - o è null. - - è negativo. - - non è modificabile. - - - Inizializza una nuova istanza della classe per il flusso specificato usando la codifica dei caratteri e le dimensioni del buffer specificate. Facoltativamente mantiene aperto il flusso. - Flusso in cui scrivere. - Codifica dei caratteri da usare. - Dimensioni del buffer, in byte. - true per mantenere il flusso aperto dopo avere eliminato l'oggetto ; in caso contrario, false. - - o è null. - - è negativo. - - non è modificabile. - - - Ottiene o imposta un valore che indica se scarica i dati del buffer nel flusso sottostante dopo ogni chiamata a . - true per forzare lo scaricamento del buffer; in caso contrario, false. - 1 - - - Ottiene il flusso sottostante che si interfaccia con un archivio di backup. - Flusso in cui StreamWriter scrive. - 2 - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - - - Ottiene l'oggetto in cui viene scritto l'output. - Oggetto specificato nel costruttore per l'istanza corrente o , se non è stata specificata alcuna codifica. - 2 - - - Cancella tutti i buffer relativi al writer corrente e consente la scrittura dei dati memorizzati nel buffer nel flusso sottostante. - Il writer corrente è chiuso. - Si è verificato un errore di I/O. - La codifica corrente non supporta la visualizzazione della metà di una coppia di surrogati Unicode. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il flusso è stato eliminato. - - - Fornisce un oggetto StreamWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive un carattere nel flusso. - Carattere da scrivere nel flusso. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una matrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere.Se è null, non viene scritta alcuna voce. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una sottomatrice di caratteri nel flusso. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Si è verificato un errore di I/O. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - 1 - - - Scrive una stringa nel flusso. - Stringa da scrivere nel flusso.Se è Null, non viene scritta alcuna voce. - - è true o il buffer di è pieno e il writer corrente è chiuso. - - è true o il buffer di è pieno e il contenuto del buffer non può essere scritto nel flusso sottostante di dimensione fissa poiché si trova al termine del flusso. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri che contiene i dati da scrivere. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere nel flusso.Se è null, non viene scritta alcuna voce. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono un carattere seguito da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una sottomatrice di caratteri seguiti da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nel flusso in modo asincrono una stringa seguita da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di flusso viene eliminato. - Il writer di flusso è attualmente utilizzato da un'operazione di scrittura precedente. - - - Implementa un oggetto che legge da una stringa. - 2 - - - Inizializza una nuova istanza della classe che legge dalla stringa specificata. - Stringa sulla quale inizializzare . - Il parametro è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Restituisce il carattere successivo disponibile senza utilizzarlo. - Integer che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il flusso non supporta la ricerca. - Il lettore corrente è chiuso. - 2 - - - Legge il carattere successivo dalla stringa di input e fa avanzare di un carattere la posizione del carattere. - Carattere successivo della stringa sottostante oppure -1 se non sono disponibili altri caratteri. - Il lettore corrente è chiuso. - 2 - - - Legge un blocco di caratteri dalla stringa di input e fa avanzare la posizione del carattere di . - Numero complessivo di caratteri letti nel buffer.È possibile che sia inferiore al numero di caratteri richiesti se la quantità di caratteri non è correntemente disponibile oppure può corrispondere a zero se è stata raggiunta la fine della stringa sottostante. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Indice iniziale nel buffer. - Numero di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge in modo asincrono un numero massimo specificato di caratteri dalla stringa corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine della stringa. - Quando il metodo restituisce un risultato, questo contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine della stringa prima che il numero di caratteri specificato venga scritto nel buffer, il metodo restituisce un risultato. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dalla stringa corrente e restituisce i dati come stringa. - Riga successiva della stringa corrente oppure null se viene raggiunta la fine della stringa. - Il lettore corrente è chiuso. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - 2 - - - Legge una riga di caratteri in modo asincrono dalla stringa corrente e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di stringhe oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Contenuto dalla posizione corrente alla fine della stringa sottostante. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il lettore corrente è chiuso. - 2 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine della stringa e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità della stringa. - Il numero di caratteri è maggiore di . - Il lettore della stringa è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Implementa un oggetto per la scrittura di informazioni in una stringa.Le informazioni vengono archiviate in un oggetto sottostante. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il controllo di formato specificato. - Oggetto che controlla la formattazione. - - - Inizializza una nuova istanza della classe che scrive nell'oggetto specificato. - Oggetto StringBuilder in cui scrivere. - - è null. - - - Inizializza una nuova istanza della classe che scrive nello specificato e dispone del provider di formato specificato. - Oggetto StringBuilder in cui scrivere. - Oggetto che controlla la formattazione. - - è null. - - - Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo le risorse non gestite. - - - Recupera l'oggetto in cui viene scritto l'output. - Encoding in cui viene scritto l'output. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di svuotamento asincrona. - - - Restituisce l'oggetto sottostante. - StringBuilder sottostante. - 2 - - - Restituisce una stringa contenente i caratteri scritti finora nell'oggetto StringWriter corrente. - Stringa contenente i caratteri scritti nell'oggetto StringWriter corrente. - 2 - - - Scrive un carattere nella stringa. - Carattere da inserire. - Il writer è chiuso. - 2 - - - Scrive una sottomatrice di caratteri nella stringa. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - Il valore di o è negativo. - ( + )> .Length. - Il writer è chiuso. - 2 - - - Scrive una stringa nella stringa corrente. - Stringa da scrivere. - Il writer è chiuso. - 2 - - - Scrive un carattere nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri nella stringa in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa nella stringa corrente in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa un carattere seguito in modo asincrono da un terminatore di riga. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nella stringa. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive nella stringa una sottomatrice di caratteri seguiti da un terminatore di riga in modo asincrono. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione nel buffer da cui iniziare la lettura dei dati. - Numero massimo di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa, seguita in modo asincrono da un terminatore di riga, nella stringa attuale. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di stringa viene eliminato. - Il writer di stringa è attualmente utilizzato da un'operazione di scrittura precedente. - - - Rappresenta un visualizzatore in grado di leggere una serie sequenziale di caratteri. - 2 - - - Inizializza una nuova istanza della classe . - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Fornisce un oggetto TextReader senza dati da cui sia possibile eseguire letture. - 1 - - - Legge il carattere successivo senza modificare lo stato del visualizzatore o dell'origine del carattere.Restituisce il successivo carattere disponibile senza leggerlo effettivamente dal lettore. - Intero che rappresenta il carattere successivo da leggere oppure -1 se non sono disponibili altri caratteri o se il lettore non supporta la ricerca. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge il carattere successivo dal lettore di testo e fa avanzare di un carattere la posizione del carattere. - Carattere successivo del lettore di testo oppure -1 se non sono disponibili altri caratteri.L'implementazione predefinita restituisce -1. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che i dati siano disponibili all'interno del lettore o meno.Se viene chiamato quando non sono più disponibili altri caratteri da leggere, questo metodo restituirà zero. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del reader prima che il numero di caratteri specificato venga letto nel buffer, il metodo restituisce un risultato. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente e scrive i dati in un buffer, a partire dall'indice specificato. - Numero di caratteri letti.Il numero sarà minore o uguale a , a seconda che tutti i caratteri di input siano stati letti o meno. - Quando questo metodo viene restituito, questo parametro contiene la matrice di caratteri specificata con i valori compresi tra i parametri e ( + -1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere. - - è null. - La lunghezza del buffer meno è minore di . - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 2 - - - Legge un numero massimo specificato di caratteri dal lettore di testo corrente in modo asincrono e scrive i dati in un buffer, a partire dall'indice specificato. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro di contiene il numero totale di byte letti nel buffer.Il valore del risultato può essere minore del numero di byte richiesti se il numero di byte attualmente disponibili è minore di quelli richiesti o può essere pari a zero se è stata raggiunta la fine del testo. - Quando questo metodo viene restituito, contiene la matrice di caratteri specificata con valori compresi tra e ( + - 1) sostituiti con i caratteri letti dall'origine corrente. - Posizione in da cui iniziare la scrittura. - Numero massimo di caratteri da leggere.Se viene raggiunta la fine del testo prima che il numero di caratteri specificato venga letto nel buffer, il metodo corrente terminerà. - - è null. - Il valore di o è negativo. - La somma di e è maggiore della lunghezza del buffer. - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge una riga di caratteri dal lettore di testo e restituisce i dati come stringa. - Riga successiva dal lettore oppure null se tutti i caratteri sono stati letti. - Si è verificato un errore di I/O. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - La classe è chiusa. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge una riga di caratteri in modo asincrono e restituisce i dati come stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene la riga successiva del lettore di testo oppure è null se tutti i caratteri sono stati letti. - Il numero di caratteri nella riga successiva è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Legge tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Stringa contenente tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo. - Si è verificato un errore di I/O. - La classe è chiusa. - La memoria disponibile non è sufficiente per assegnare un buffer per la stringa restituita. - Il numero di caratteri nella riga successiva è maggiore di - 1 - - - Legge in modo asincrono tutti i caratteri dalla posizione corrente fino alla fine del lettore di testo e li restituisce come singola stringa. - Attività che rappresenta l'operazione di lettura asincrona.Il valore del parametro contiene una stringa con i caratteri compresi tra la posizione corrente e l'estremità del lettore di testo. - Il numero di caratteri è maggiore di . - Il lettore di testo è stato eliminato. - Il lettore è al momento utilizzato da un'operazione di lettura precedente. - - - Rappresenta un writer in grado di scrivere una serie sequenziale di caratteri.Questa classe è astratta. - 2 - - - Inizializza una nuova istanza della classe . - - - Inizializza una nuova istanza della classe con il provider di formato specificato. - Oggetto che controlla la formattazione. - - - Archivia i caratteri di nuova riga usati per questo TextWriter. - - - Rilascia tutte le risorse usate dall'oggetto . - - - Rilascia le risorse non gestite usate da e, facoltativamente, le risorse gestite. - true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. - - - Se sottoposto a override in una classe derivata, restituisce la codifica caratteri in cui viene scritto l'output. - Codifica caratteri in cui viene scritto l'output. - 1 - - - Cancella i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - 1 - - - Cancella in modo asincrono i dati di tutti i buffer del writer corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. - Attività che rappresenta l'operazione di scaricamento asincrona. - Il writer di testo viene eliminato. - Il writer è attualmente utilizzato da un'operazione di scrittura precedente. - - - Ottiene un oggetto che controlla la formattazione. - Oggetto per impostazioni cultura specifiche oppure la formattazione delle impostazioni cultura correnti se non sono specificate altre impostazioni cultura. - 2 - - - Recupera o imposta la stringa di terminazione di riga usata dall'oggetto TextWriter corrente. - Stringa di terminazione di riga relativa all'oggetto TextWriter corrente. - 2 - - - Fornisce un oggetto TextWriter senza archivio di backup, in cui è possibile scrivere, ma da cui non è possibile leggere. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore Boolean. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere nella stringa o flusso di testo. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri nella stringa o flusso di testo. - Matrice di caratteri da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri nel flusso o nella stringa di testo. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore decimale. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 8 byte. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte con segno. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte con segno. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un oggetto chiamando il metodo ToString su tale oggetto. - Oggetto da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un valore a virgola mobile a 4 byte. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa nella stringa o nel flusso di testo. - Stringa da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - - o è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 4 byte senza segno. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nel flusso o nella stringa di testo la rappresentazione in forma di testo di un intero a 8 byte senza segno. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un carattere in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una matrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se è null, non viene scritta alcuna voce. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una sottomatrice di caratteri in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive una stringa in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se è null, nel flusso di testo non viene scritto alcun dato. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive un terminatore di riga nel flusso o nella stringa di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore Boolean, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore Boolean da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive nella stringa o nel flusso di testo un carattere seguito da un terminatore di riga. - Carattere da scrivere nel flusso di testo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Matrice di caratteri da cui vengono letti i dati. - Posizione del carattere in dalla quale avviare la lettura dei dati. - Numero massimo di caratteri da scrivere. - La lunghezza del buffer meno è minore di . - Il valore del parametro è null. - Il valore di o è negativo. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione in forma di testo di un valore decimale, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore decimale da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 8 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 8 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 4 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte con segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte con segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un oggetto chiamando il metodo ToString sull'oggetto, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Oggetto da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un valore a virgola mobile a 4 byte, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Valore a virgola mobile a 4 byte da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Stringa da scrivere.Se il parametro è null, verrà scritto solo il terminatore di riga. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è uno). - 1 - - - Scrive una stringa formattata e una nuova riga nella stringa o nel flusso di testo, usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è due). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Primo oggetto da formattare e scrivere. - Secondo oggetto da formattare e scrivere. - Terzo oggetto da formattare e scrivere. - - è null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale al numero di oggetti da formattare (che, per questo overload del metodo, è tre). - 1 - - - Scrive una stringa formattata e una nuova riga usando la stessa semantica del metodo . - Stringa in formato composito (vedere la sezione Note). - Matrice di oggetti che contiene zero o più oggetti da formattare e scrivere. - Viene passato un oggetto o una stringa come null. - La classe è chiusa. - Si è verificato un errore di I/O. - - non è una stringa di formato composto valido.-oppure- L'indice di un elemento di formato è minore di 0 (zero) o maggiore o uguale alla lunghezza della matrice . - 1 - - - Scrive la rappresentazione in forma di testo di un intero a 4 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 4 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive la rappresentazione testuale di un intero a 8 byte senza segno, seguita da un terminatore di riga, nella stringa o nel flusso di testo. - Intero a 8 byte senza segno da scrivere. - La classe è chiusa. - Si è verificato un errore di I/O. - 1 - - - Scrive un terminatore di riga in modo asincrono nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono un carattere seguito da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Carattere da scrivere nel flusso di testo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una matrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da scrivere nel flusso di testo.Se la matrice di caratteri è null, viene scritto solo il terminatore di riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una sottomatrice di caratteri seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Matrice di caratteri da cui scrivere i dati. - Posizione del carattere nel buffer da cui iniziare il recupero dei dati. - Numero di caratteri da scrivere. - - è null. - - e sono maggiori della lunghezza del buffer. - Il valore di o è negativo. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - Scrive in modo asincrono una stringa seguita da un terminatore di riga nella stringa o nel flusso di testo. - Attività che rappresenta l'operazione di scrittura asincrona. - Stringa da scrivere.Se il valore è null, verrà scritto solo il terminatore della riga. - Il writer di testo viene eliminato. - Il writer di testo è attualmente utilizzato da un'operazione di scrittura precedente. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml deleted file mode 100644 index 4114d626..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/ja/System.IO.xml +++ /dev/null @@ -1,2264 +0,0 @@ - - - - System.IO - - - - プリミティブ データ型を特定のエンコーディングのバイナリ値として読み取ります。 - 2 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 入力ストリーム。 - 使用する文字エンコーディング。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - は null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 入力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが読み取りをサポートしていないか、null であるか、既に閉じています。 - - または が null です。 - - - - の基になるストリームへのアクセスを公開します。 - BinaryReader に関連付けられた、基になるストリーム。 - 2 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 指定したバイト数分だけストリームから読み取ったバイトを内部バッファーに格納します。 - 読み取るバイト数。 - - 分のバイトを読み取る前にストリームの末尾に到達しました。 - I/O エラーが発生しました。 - 要求された が、内部バッファー サイズより大きくなっています。 - - - 読み取り可能な次の文字を返します。バイトの位置または文字の位置は変化しません。 - 使用できる次の文字。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 現在の文字は、ストリーム用に選択された を使用して内部文字バッファーにデコードできません。 - 2 - - - 基になるストリームから文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 入力ストリームの次の文字。現在読み取り可能な文字がない場合は -1。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - バイト配列内の指定された位置を開始点として、ストリームから指定されたバイト数を読み取ります。 - - に読み取るバイト数。要求したバイト数分のバイトを読み取れなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取るバイト数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 文字配列内の指定された位置を開始点として、ストリームから指定された文字数を読み取ります。 - バッファーに読み取られた合計文字数。要求した文字数分の文字を読み取れなかった場合、この値は要求した文字数より小さくなります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを読み取るバッファー。 - バッファー内の、バッファーへの読み取り開始点。 - 読み取る文字の数。 - バッファー長から を差し引いた値が より小さい値です。またはデコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - - は null です。 - - または が負の値です。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 32 ビット整数を圧縮形式で読み取ります。 - 圧縮形式の 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - ストリームが破損しています。 - - - 現在のストリームから Boolean 値を読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 読み取ったバイトが 0 以外の場合は true。0 の場合は false。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから次のバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った次のバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから指定されたバイト数をバイト配列に読み取り、そのバイト数だけストリーム内の現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されているバイト配列。ストリームの末尾に到達した場合は要求したバイト数より小さくなることがあります。 - 読み取るバイト数。この値は 0 以上の数字の必要があり、それ以外の場合は例外が発生します。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - が負の値です。 - 2 - - - 現在のストリームの次の文字を読み取り、使用した Encoding とストリームから読み取った特定の文字に従ってストリームの現在位置を進めます。 - 現在のストリームから読み取った文字。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - サロゲート文字が読み取られました。 - 2 - - - 現在のストリームから指定された文字数を読み取り、そのデータを文字配列として返します。また、使用した Encoding とストリームから読み取った特定の文字に従って現在位置を進めます。 - 基になるストリームから読み取ったデータが格納されている文字配列。ストリームの末尾に到達した場合は、要求された文字数より小さくなることがあります。 - 読み取る文字の数。 - デコードされた文字の数が を超えています。これは、Unicode デコーダーがフォールバック文字またはサロゲート ペアを返す場合に発生することがあります。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - - が負の値です。 - 2 - - - 現在のストリームから 10 進数値を読み取り、ストリームの現在位置を 16 バイトだけ進めます。 - 現在のストリームから読み取った 10 進数値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト浮動小数点値を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 2 バイト符号付き整数を読み取り、ストリームの現在位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号付き整数を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号付き整数を読み取り、ストリームの現在位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号付き整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから符号付きバイトを読み取り、ストリームの現在位置を 1 バイトだけ進めます。 - 現在のストリームから読み取った符号付きバイト。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト浮動小数点値を読み取り、ストリームの現在位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト浮動小数点値。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 1 つの文字列を読み取ります。ストリームの文字列は、7 ビットごとにエンコードされた文字列の長さが先頭に付加されています。 - 読み取った文字列。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - リトル エンディアン エンコーディングを使用して現在のストリームから 2 バイト符号なし整数を読み取り、ストリームの位置を 2 バイトだけ進めます。 - 現在のストリームから読み取った 2 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 4 バイト符号なし整数を読み取り、ストリームの位置を 4 バイトだけ進めます。 - 現在のストリームから読み取った 4 バイト符号なし整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 2 - - - 現在のストリームから 8 バイト符号なし整数を読み取り、ストリームの位置を 8 バイトだけ進めます。 - 現在のストリームから読み取った 8 バイト符号なし整数。 - ストリームの末尾に到達しました。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 2 - - - プリミティブ型をバイナリでストリームに書き込みます。特定のエンコーディングの文字列の書き込みをサポートします。 - 2 - - - ストリームへの書き込みを行う クラスの新しいインスタンスを初期化します。 - - - 指定したストリームに基づき、UTF-8 エンコーディングを使用する クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - は null なので、 - - - 指定したストリームと文字エンコーディングに基づいて、 クラスの新しいインスタンスを初期化します。 - 出力ストリーム。 - 使用する文字エンコーディング。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - 指定したストリームと文字エンコーディングに基づいて クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 出力ストリーム。 - 使用する文字エンコーディング。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - - または が null です。 - - - - の基になるストリームを取得します。 - BinaryWriter に関連付けられた、基になるストリーム。 - 1 - - - - クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - バッキング ストアを持たない を指定します。 - 1 - - - 基になるストリームを保持します。 - - - 現在のストリーム内の位置を設定します。 - 現在のストリームの位置。 - - からのバイト オフセット。 - 新しい位置を取得するための参照ポイントを示す フィールド。 - ファイル ポインターが無効な位置に移動しました。 - - 値が無効です。 - 1 - - - 現在のストリームに 1 バイト Boolean 値を書き込みます。値 0 は false を表し、値 1 は true を表します。 - 書き込む Boolean 値 (0 または 1)。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号なしバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号なしバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 基になるストリームにバイト配列を書き込みます。 - 書き込むデータが格納されているバイト配列。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は null なので、 - 1 - - - 現在のストリームにバイト配列の特定の領域を書き込みます。 - 書き込むデータが格納されているバイト配列。 - - 内の書き込み開始点。 - 書き込むバイト数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに Unicode 文字を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む非サロゲート Unicode 文字。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - - は、単一のサロゲート文字です。 - 1 - - - 現在のストリームに文字配列を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - は null なので、 - ストリームが閉じられました。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームに文字配列の特定の領域を書き込み、使用した Encoding とストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込むデータを格納する文字配列。 - - 内の書き込み開始点。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null なので、 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 10 進数値を書き込み、ストリームの位置を 16 バイトだけ進めます。 - 書き込む 10 進値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト浮動小数点値を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号付き整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号付き整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号付き整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号付き整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに符号付きバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - 書き込む符号付きバイト。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト浮動小数点値を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト浮動小数点値。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 文字長プリフィックスを持つ文字列を、 の現在のエンコーディングでこのストリームに書き込み、使用したエンコーディングとストリームに書き込んだ特定の文字に従ってストリームの現在位置を進めます。 - 書き込む値。 - I/O エラーが発生しました。 - - は null なので、 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 2 バイト符号なし整数を書き込み、ストリームの位置を 2 バイトだけ進めます。 - 書き込む 2 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 4 バイト符号なし整数を書き込み、ストリームの位置を 4 バイトだけ進めます。 - 書き込む 4 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 現在のストリームに 8 バイト符号なし整数を書き込み、ストリームの位置を 8 バイトだけ進めます。 - 書き込む 8 バイト符号なし整数。 - I/O エラーが発生しました。 - ストリームが閉じられました。 - 1 - - - 32 ビット整数を圧縮形式で書き込みます。 - 書き込む 32 ビット整数。 - ストリームの末尾に到達しました。 - ストリームが閉じられました。 - ストリームが閉じられました。 - - - ストリームの末尾を越えて読み込もうとしたときにスローされる例外。 - 2 - - - メッセージ文字列がシステムによって提供されたメッセージに設定され、HRESULT が COR_E_ENDOFSTREAM に設定された クラスの新しいインスタンスを初期化します。 - - - メッセージ文字列を に設定し、HRESULT を COR_E_ENDOFSTREAM に設定して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - - - 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 - エラーを説明する文字列。 の内容は、ユーザーが理解できる内容にします。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - データ ストリームが無効な形式である場合にスローされる例外。 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - - - この例外の原因である内部例外への参照を指定して、 クラスの新しいインスタンスを初期化します。 - 例外の原因を説明するエラー メッセージ。 - 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 - - - バッキング ストアとしてメモリを使用するストリームを作成します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを、0 に初期化される拡張可能な容量を使用して 初期化します。 - - - 指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - 現在のストリームを作成する符号なしバイトの配列。 - - は null です。 - - - - プロパティを指定どおりに設定し、指定したバイト配列に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - - バイト配列の指定した領域 (インデックス) に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - - は null です。 - - または が 0 未満です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、バイト配列の指定した領域に基づいて、サイズを変更できない クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - プロパティを指定どおりに設定し、 を呼び出す機能を指定どおりに設定して、バイト配列の指定した領域に基づき、 クラスの新しいインスタンスを初期化します。 - このストリームの作成元の符号なしバイトの配列。 - ストリームが開始する位置の のインデックス。 - バイト単位のストリーム長。 - ストリームが書き込みをサポートするかどうかを決定する プロパティの設定。 - ストリームの作成元の符号なしバイト配列を返す を有効にする場合は true。それ以外の場合は false。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - - - - クラスの新しいインスタンスを、指定に従って初期化される拡張可能な容量を使用して初期化します。 - バイト単位の内部配列の初期サイズ。 - - が負の値です。 - - - 現在のストリームが読み取りをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームがシークをサポートしているかどうかを示す値を取得します。 - ストリームが開いている場合は true。 - 2 - - - 現在のストリームが書き込みをサポートしているかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 2 - - - ストリームに割り当てられたバイト数を取得または設定します。 - ストリームに対してバッファーが使用できる部分の長さ。 - 容量が負の値または現在のストリーム長より小さい値に設定されています。 - 現在のストリームが閉じています。 - 容量を変更できないストリームに対して set が呼び出されました。 - 2 - - - 指定されたバッファー サイズを使用して、現在のストリームからすべてのバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。 - キャンセル要求を監視するためのトークン。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - クラスによって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - アクションが実行されないように、 メソッドをオーバーライドします。 - 2 - - - このストリームのすべてのバッファーを非同期的にクリアし、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。 - ストリームは破棄されています。 - - - バイト単位のストリーム長を取得します。 - バイト単位のストリーム長。 - ストリームが閉じられました。 - 2 - - - ストリームの現在位置を取得または設定します。 - ストリーム内の現在位置。 - 位置が負の値または より大きい値に設定されています。 - ストリームが閉じられました。 - 2 - - - 現在のストリームからバイトのブロックを読み取り、データをバッファーに書き込みます。 - バッファーに書き込まれた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。また、データを読み取る前にストリームの末尾に到達した場合は 0 になります。 - このメソッドが戻るとき、指定したバイト配列の から ( + - 1) までの値が、現在のストリームから読み取られた文字に置き換えられています。 - 現在のストリームからのデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - バッファー長から を差し引いた値が より小さい値です。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームからバイトを読み取ります。 - - にキャストしたバイト。ストリームの末尾に達した場合は -1。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム内の位置を指定した値に設定します。 - 初期参照ポイントとオフセットを組み合わせて計算するストリーム内の新しい位置。 - ストリームの新しい位置。これは パラメーターに対する相対値であり、正または負の値にできます。 - シーク参照ポイントとして機能する 型の値。 - ストリームの先頭より前をシークしようとしました。 - - が より大きくなっています。 - 無効な があります。または によって算術オーバーフローが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリーム長を指定した値に設定します。 - 長さを設定する値。 - 現在のストリームのサイズが変更できません。 が現在の容量を超えています。または 現在のストリームが書き込みをサポートしません。 - - が負または の最大長より大きな値です。最大長は、( - origin) で計算され、origin は、ストリームが開始する位置を示す基になるバッファーのインデックスです。 - 2 - - - - プロパティには関係なく、ストリームの内容をバイト配列に書き込みます。 - 新しいバイト配列。 - 2 - - - このストリームの作成元の符号なしバイトの配列を返します。戻り値は、変換が成功したかどうかを示します。 - 変換が成功した場合は true。それ以外の場合は false。 - このストリームの作成元のバイト配列セグメント。 - - - バッファーから読み取ったデータを使用して、現在のストリームにバイトのブロックを書き込みます。 - データの書き込み元となるバッファー。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置が、ストリームの末尾に向かって バイトよりも近い位置にあり、容量を変更できません。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - 現在のストリーム インスタンスが閉じています。 - 2 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリーム内の現在位置に 1 バイトを書き込みます。 - 書き込むバイト。 - ストリームは書き込みをサポートしません。詳細については、 のトピックを参照してください。または 現在の位置がストリームの末尾になっており、容量を変更できません。 - 現在のストリームが閉じています。 - 2 - - - メモリ ストリームの内容全体を別のストリームに書き込みます。 - このメモリ ストリームが書き込まれるストリーム。 - - は null です。 - 現在のストリームまたは対象のストリームは閉じています。 - 2 - - - シークに使用するストリームの場所を指定します。 - 2 - - - ストリームの先頭を指定します。 - - - ストリーム内の現在位置を指定します。 - - - ストリームの末尾を指定します。 - - - バイト シーケンスのジェネリック ビューを提供します。これは抽象クラスです。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが読み取りをサポートするかどうかを示す値を取得します。 - ストリームが読み込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームがシークをサポートするかどうかを示す値を取得します。 - ストリームがシークをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームがタイムアウトできるかどうかを決定する値を取得します。 - 現在のストリームがタイムアウトできるかどうかを決定する値。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリームが書き込みをサポートするかどうかを示す値を取得します。 - ストリームが書き込みをサポートしている場合は true。それ以外の場合は false。 - 1 - - - 現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームは読み取りをサポートしていません。または は、書き込みをサポートしません。 - - メソッドが呼び出される前に、現在のストリームまたは が閉じられました。 - I/O エラーが発生しました。 - - - 現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - - は null です。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - 指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。 - 非同期のコピー操作を表すタスク。 - 現在のストリームの内容のコピー先のストリーム。 - バッファーのサイズ (バイト数)。これは、0 より大きい値である必要があります。既定のサイズは 81920 です。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - が負の値またはゼロです。 - 現在のストリームまたはコピー先ストリームは破棄されます。 - 現在のストリームが読み取りをサポートしていないか、コピー先のストリームが書き込みをサポートしていません。 - - - - によって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされた場合は、ストリームに対応するすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - I/O エラーが発生しました。 - 2 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込み、キャンセル要求を監視します。 - 非同期のフラッシュ操作を表すタスク。 - キャンセル要求を監視するためのトークン。既定値は です。 - ストリームは破棄されています。 - - - 派生クラスでオーバーライドされた場合は、ストリームの長さをバイト単位で取得します。 - ストリーム長 (バイト単位) を表す long 値。 - Stream から派生したクラスがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - バッキング ストアを持たない Stream。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を取得または設定します。 - ストリーム内の現在位置。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。 - バッファーに読み取られた合計バイト数。要求しただけのバイト数を読み取ることができなかった場合、この値は要求したバイト数より小さくなります。ストリームの末尾に到達した場合は 0 (ゼロ) になることがあります。 - バイト配列。このメソッドが戻るとき、指定したバイト配列の から ( + -1) までの値が、現在のソースから読み取られたバイトに置き換えられます。 - 現在のストリームから読み取ったデータの格納を開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームから読み取る最大バイト数。 - - と の合計値が、バッファー長より大きい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから非同期的にバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - データを書き込むバッファー。 - ストリームからのデータの書き込み開始位置を示す 内のバイト オフセット。 - 読み取る最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは読み取りをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の読み取り操作で使用中です。 - - - ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。 - Int32 にキャストされた符号なしバイト。ストリームの末尾の場合は -1。 - ストリームは読み取りをサポートしません。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に読み取りを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 派生クラスでオーバーライドされた場合は、現在のストリーム内の位置を設定します。 - 現在のストリーム内の新しい位置。 - - パラメーターからの相対バイト オフセット。 - 新しい位置を取得するために使用する参照ポイントを示す 型の値。 - I/O エラーが発生しました。 - ストリームがシークをサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 1 - - - 派生クラスでオーバーライドされた場合は、現在のストリームの長さを設定します。 - 現在のストリームの希望の長さ (バイト数)。 - I/O エラーが発生しました。 - ストリームが書き込みとシークの両方をサポートしていません。たとえば、ストリームがパイプまたはコンソール出力によって生成された可能性があります。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - 派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。 - バイト配列。このメソッドは、 から現在のストリームに、 で指定されたバイト数だけコピーします。 - 現在のストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 現在のストリームに書き込むバイト数。 - 合計  と  がバッファーの長さより大きい。 - - nullです。 - - または  が負の値です。 - 指定したファイルが見つからないなど、I/O エラーが発生しました。 - ストリームは書き込みをサポートしません。 - - ストリームが閉じられた後が呼び出されました。 - 1 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - 現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元となるバッファー。 - ストリームへのバイトのコピーを開始する位置を示す 内のバイト オフセット。インデックス番号は 0 から始まります。 - 書き込む最大バイト数。 - キャンセル要求を監視するためのトークン。既定値は です。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは書き込みをサポートしません。 - ストリームは破棄されています。 - ストリームは現在、前の書き込み操作で使用中です。 - - - ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。 - ストリームに書き込むバイト。 - I/O エラーが発生しました。 - ストリームが書き込みをサポートしていないか、既に閉じています。 - ストリームが閉じられた後でメソッドが呼び出されました。 - 2 - - - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位) を取得または設定します。 - ストリームがタイムアウト前に書き込みを試行する期間を決定する値 (ミリ秒単位)。 - - メソッドは、常に をスローします。 - 2 - - - 特定のエンコーディングのバイト ストリームから文字を読み込む を実装します。この種類の .NET Framework ソース コードを参照して、次を参照してください。、 Reference Sourceです。 - 1 - - - 指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - - が読み取りをサポートしていません。 - - は null です。 - - - バイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - は null です。 - - - 文字エンコーディングを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディングとバイト順マーク検出オプションを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - - が読み取りをサポートしていません。 - - または が null です。 - - - 文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズを設定して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 読み込まれるストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索するかどうかを示します。 - 最小バッファー サイズ。 - ストリームは読み取りをサポートしません。 - - または が null です。 - - が 0 以下です。 - - - 指定した文字エンコーディング、バイト順マーク検出オプション、およびバッファー サイズに基づいて、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 読み取るストリーム。 - 使用する文字エンコーディング。 - ファイルの先頭にあるバイト順序マークを検索する場合は true。それ以外の場合は false。 - 最小バッファー サイズ。 - - オブジェクトを破棄した後にストリームを開いたままにする場合は true、それ以外の場合は false。 - - - 基になるストリームを返します。 - 基になるストリーム。 - 2 - - - 現在の オブジェクトが使用している現在の文字エンコーディングを取得します。 - 現在のリーダーが使用している現在の文字エンコーディング。 の メソッドを最初に呼び出した後、現在の文字エンコーディングを示す値が異なる場合があります。これは、 メソッドの最初の呼び出しまでエンコードの自動検出が実行されないためです。 - 2 - - - 内部バッファーをクリアします。 - 2 - - - 基になるストリームを閉じ、 によって使用されているアンマネージ リソースを解放します。任意でマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 現在のストリームの位置がストリームの末尾かどうかを示す値を取得します。 - 現在のストリームの位置がストリームの末尾の場合は true。それ以外の場合は false。 - 基になるストリームは破棄されています。 - 1 - - - 空のストリームの オブジェクト。 - 1 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。読み取り対象の文字が存在しない場合またはストリームがシークをサポートしていない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 入力ストリームから次の文字を読み込み、1 文字分だけ文字位置を進めます。 - 入力ストリームの次の文字を オブジェクトで表した値。使用できる文字がない場合は -1。 - I/O エラーが発生しました。 - 1 - - - 指定したインデックスを開始位置として、現在のストリームから、指定された最大文字数をバッファー内に読み取ります。 - 読み込まれた文字数。ストリームの末尾でデータが読み込まれなかった場合は 0。この数値は、ストリーム内に使用できるデータがあるかどうかによって異なりますが、 パラメーター以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みの開始位置を示す のインデックス。 - 読み取り対象の最大文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - は null です。 - - または が負の値です。 - I/O エラーが発生しました。たとえば、ストリームがクローズされています。 - 1 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合は現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のストリームから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から () までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - - - 指定した最大文字数を現在のストリームから非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、ストリームの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前にストリームの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在のストリームから 1 行分の文字を読み取り、そのデータを文字列として返します。 - 入力ストリームからの次の行。入力ストリームの末尾に到達した場合は null。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在のストリームから非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、ストリームの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - すべての文字の現在位置から末尾までを読み込みます。 - ストリームの現在位置から末尾までのストリームの残り部分 (文字列)。現在の位置がストリームの末尾である場合は、空の文字列 ("") が返されます。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - I/O エラーが発生しました。 - 1 - - - 現在位置からストリームの末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からストリームの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - ストリームは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字を特定のエンコーディングでストリームに書き込むための を実装しています。この種類の .NET Framework ソース コードを参照して、次を参照してください。、参照ソースです。 - 1 - - - UTF-8 エンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - - が書き込み可能ではありません。 - - は null です。 - - - 指定したエンコーディングと既定のバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - - または が null です。 - - が書き込み可能ではありません。 - - - 指定したエンコーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化します。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - 指定した円コーディングとバッファー サイズを使用して、指定したストリーム用の クラスの新しいインスタンスを初期化し、必要に応じて、ストリームを開いたままにします。 - 書き込まれるストリーム。 - 使用する文字エンコーディング。 - バイト単位のバッファー サイズ。 - true to leave the stream open after the object is disposed; otherwise, false. - - または が null です。 - - が負の値です。 - - が書き込み可能ではありません。 - - - - が呼び出されるたびに、 によって基になるストリームに対するバッファーをフラッシュするかどうかを示す値を取得または設定します。 - - に強制的にバッファーをフラッシュさせる場合は true。それ以外の場合は false。 - 1 - - - バッキング ストアと連結する、基になるストリームを取得します。 - この StreamWriter が書き込むストリーム。 - 2 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - - - 出力の書き込みに使用する を取得します。 - 現在のインスタンスのコンストラクターで指定した 。エンコーディングを指定しなかった場合は、。 - 2 - - - 現在のライターで使用したすべてのバッファーをクリアし、バッファー内のすべてのデータを基になるストリームに書き込みます。 - 現在のライターがクローズされています。 - I/O エラーが発生しました。 - 現在のエンコードは、Unicode サロゲート ペアの片方の表示をサポートしていません。 - 1 - - - このストリームのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - ストリームは破棄されています。 - - - バッキング ストアを持たない書き込み専用の StreamWriter を提供します。 - 1 - - - ストリームに文字を書き込みます。 - ストリームに書き込む文字。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列を書き込みます。 - 書き込むデータを格納する文字配列。 が null の場合は、何も書き込まれません。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字配列の一部を書き込みます。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - I/O エラーが発生しました。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - 1 - - - ストリームに文字列を書き込みます。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - - が true または バッファーがいっぱいで、現在のライターが閉じられています。 - - が true または バッファーがいっぱいで、 がストリームの末尾にあるため、基になる固定サイズのストリームにバッファーの内容を書き込むことができません。 - I/O エラーが発生しました。 - 1 - - - 文字を非同期でストリームに書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込むデータを格納する文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字列。 が null の場合は、何も書き込まれません。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をストリームに非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 非同期でストリームに文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - ストリームに書き込む文字。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をストリームに非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の文字位置。 - 書き込む文字の最大数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列を非同期でストリームに書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - ストリーム ライターは破棄されます。 - ストリーム ライターは現在、前の書き込み操作で使用中です。 - - - 文字列から読み取る を実装します。 - 2 - - - 指定した文字列から読み取る クラスの新しいインスタンスを初期化します。 - - を初期化する目的の文字列。 - - パラメーターが null です。 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り可能な次の文字を返しますが、その文字は使用されません。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、ストリームがシークをサポートしていない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から次の文字を読み取り、1 文字分だけ文字位置を進めます。 - 基になる文字列の次の文字。または使用できる文字がない場合は -1。 - 現在のリーダーが閉じています。 - 2 - - - 入力文字列から文字のブロックを読み取り、 だけ文字位置を進めます。 - バッファーに読み取られた合計文字数。要求しただけの文字数を読み取ることができなかった場合、この値は要求した文字数より小さくなります。基になる文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - バッファー内の開始インデックス。 - 読み取る文字の数。 - - は null なので、 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - 現在のリーダーが閉じています。 - 2 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在の文字列から非同期的に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、文字列の末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに書き込む前に文字列の末尾に到達した場合、メソッドは制御を返します。 - - は null なので、 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在の文字列から 1 行分の文字を読み取り、そのデータを文字列として返します。 - 現在の文字列の次の行。文字列の末尾に到達した場合は null。 - 現在のリーダーが閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 2 - - - 現在の文字列から非同期的に 1 行分の文字を読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、文字列リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 現在位置から文字列の末尾まですべての文字を読み取り、1 つの文字列として返します。 - 基になる文字列の現在位置から末尾までの内容。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 現在のリーダーが閉じています。 - 2 - - - 現在位置から文字列の末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置から文字列の末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - 文字列リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 文字列に情報を書き込む を実装します。情報は、基になる に格納されます。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式コントロールで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - 指定した への書き込みを行う クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - - は null なので、 - - - 指定した に書き込みを行い、指定した書式プロバイダーを持つ クラスの新しいインスタンスを初期化します。 - 書き込む StringBuilder。 - 書式を制御する オブジェクト。 - - は null なので、 - - - - によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 出力の書き込みに使用する を取得します。 - 出力の書き込み時に適用する Encoding。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - - - 基になる を返します。 - 基になる StringBuilder。 - 2 - - - 現在の StringWriter に書き込まれた文字を格納している文字列を返します。 - 現在の StringWriter に書き込まれた文字を格納している文字列。 - 2 - - - 文字列に文字を書き込みます。 - 書き込む文字。 - ライターが閉じられました。 - 2 - - - 文字配列の一部を文字列に書き込みます。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - または が負の値です。 - ( + )> 。Length. - ライターが閉じられました。 - 2 - - - 現在の文字列に文字列を書き込みます。 - 書き込む文字列。 - ライターが閉じられました。 - 2 - - - 文字列に文字を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に文字列を非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 非同期で文字列に文字を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 文字列に書き込む文字。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列を文字列に非同期で書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの読み取りを開始する、バッファー内の位置。 - 書き込む文字の最大数。 - - は null なので、 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 現在の文字列に非同期で文字列を書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - 文字列ライターは破棄されます。 - 文字列ライターは現在、前の書き込み操作で使用中です。 - - - 一連の文字を読み取ることができるリーダーを表します。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 読み取り対象のデータを TextReader に提供しません。 - 1 - - - リーダーや文字の読み取り元の状態を変更せずに、次の文字を読み取ります。リーダーから実際に文字を読み取らずに次の文字を返します。 - 読み取り対象の次の文字を表す整数。使用できる文字がないか、リーダーがシークをサポートしていない場合は -1。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - テキスト リーダーから次の文字を読み取り、1 文字分だけ文字位置を進めます。 - テキスト リーダーからの次の文字。それ以上読み取り可能な文字がない場合は -1。既定の実装では、-1 が返されます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のリーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、リーダー内に使用できるデータがあるかどうかによって異なりますが、 以下の数値になります。読み取り対象の文字がない場合にこのメソッドを呼び出すと、0 (ゼロ) が返されます。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にリーダーの末尾に到達した場合、メソッドは制御を返します。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 指定した最大文字数を現在のテキスト リーダーから読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 読み取られた文字数。この数値は、すべての入力文字が読み取られたかどうかによって異なりますが、 以下の数値になります。 - このメソッドが戻るとき、指定した文字配列の から ( + -1) までの値が、現在のソースから読み取られた文字に置き換えられています。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。 - - は null です。 - バッファー長から を差し引いた値が より小さい値です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 2 - - - 指定した最大文字数を現在のテキスト リーダーから非同期に読み取り、バッファーの指定したインデックス位置にそのデータを書き込みます。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、バッファーに読み込まれるバイトの合計数が含まれます。現在使用できるバイト数が要求した数より小さい場合、結果の値は要求したバイト数より小さくなることがあります。また、テキストの末尾に到達した場合は 0 になることがあります。 - このメソッドが戻るとき、指定した文字配列の から ( + - 1) までの値が、現在のソースから読み取られた文字に置き換えられます。 - 書き込みを開始する 内の位置。 - 読み取り対象の最大文字数。指定された文字数をバッファーに読み取る前にテキストの末尾に到達した場合は、現在のメソッドが返ります。 - - は null です。 - - または が負の値です。 - - と の合計値が、バッファー長より大きい値です。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーから 1 行分の文字を読み取り、そのデータを文字列として返します。 - リーダーの次の行。またはすべての文字が読み取られた場合は null。 - I/O エラーが発生しました。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - - が閉じています。 - 次の行の文字数が、 を超えています。 - 1 - - - 1 行分の文字を非同期的に読み取り、そのデータを文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、テキスト リーダーの次の行が含まれます。または、すべての文字が読み取られた場合は null です。 - 次の行の文字数が、 を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - テキスト リーダーの現在位置から末尾まですべての文字を読み取り、1 つの文字列として返します。 - テキスト リーダーの現在位置から末尾までのすべての文字を含む文字列。 - I/O エラーが発生しました。 - - が閉じています。 - 返される文字列用のバッファーを割り当てるためにはメモリが不足しています。 - 次の行の文字数が、 を超えています。 - 1 - - - テキスト リーダーの現在位置から末尾まですべての文字を非同期的に読み取り、1 つの文字列として返します。 - 非同期の読み取り操作を表すタスク。 パラメーターの値には、現在位置からテキスト リーダーの末尾までの文字から成る文字列が含まれます。 - 文字数が を超えています。 - テキスト リーダーは破棄されています。 - リーダーは現在、前の読み取り操作で使用中です。 - - - 一連の文字を書き込むことができるライターを表します。このクラスは抽象クラスです。 - 2 - - - - クラスの新しいインスタンスを初期化します。 - - - 指定した書式プロバイダーで クラスの新しいインスタンスを初期化します。 - 書式を制御する オブジェクト。 - - - この TextWriter で使用する改行文字を格納します。 - - - この オブジェクトによって使用されているすべてのリソースを解放します。 - - - - で使用されているアンマネージ リソースを解放し、オプションでマネージ リソースを解放します。 - マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 - - - 派生クラスによってオーバーライドされると、出力を書き込む文字エンコーディングを返します。 - 出力の書き込み時に適用する文字エンコーディング。 - 1 - - - 現在のライターのすべてのバッファーをクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 1 - - - 現在のライターのすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。 - 非同期のフラッシュ操作を表すタスク。 - テキスト ライターは破棄されます。 - ライターは現在、前の書き込み操作で使用中です。 - - - 書式を制御するオブジェクトを取得します。 - 特定のカルチャ設定の オブジェクト、または他のカルチャ設定が指定されていない場合は現在のカルチャ設定の書式。 - 2 - - - 現在の TextWriter で使用される行終端文字列を取得または設定します。 - 現在の TextWriter で使用する行終端文字列。 - 2 - - - バッキング ストアを持たない書き込み専用の TextWriter を提供します。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字配列をテキスト文字列またはストリームに書き込みます。 - テキスト ストリームに書き込む文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込みます。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込むオブジェクト。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込みます。 - 書き込む文字列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - - または が null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。 が null の場合は、何も書き込まれません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。 が null の場合は、何もテキスト ストリームに書き込みません。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 行終端記号をテキスト文字列またはストリームに書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - Boolean 値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む Boolean 値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - テキスト ストリームに書き込む文字。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字の部分配列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - データの読み取り元の文字配列。 - データの読み込みを開始する、 内の文字の位置。 - 書き込む文字の最大数。 - バッファー長から を差し引いた値が より小さい値です。 - - パラメーターが null です。 - - または が負の値です。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 10 進値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 10 進値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号付き整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号付き整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - オブジェクトで ToString メソッドを呼び出して、そのオブジェクトのテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込むオブジェクト。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 4 バイト浮動小数点値のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト浮動小数点値。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 文字列をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む文字列。 が null の場合は、行終端記号だけを書き込みます。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをするオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 1) 以上です。 - 1 - - - - メソッドと同じセマンティクスを使用して、書式設定された文字列と改行をテキスト文字列またはストリームに書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 2) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする最初のオブジェクト。 - 書式設定および書き込みをする 2 番目のオブジェクト。 - 書式設定および書き込みをする 3 番目のオブジェクト。 - - は null です。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式指定項目のインデックスが、0 (ゼロ) より小さいか、書式設定されるオブジェクトの数 (このメソッド オーバーロードでは 3) 以上です。 - 1 - - - - と同じセマンティクスを使用して、書式設定された文字列と改行を書き込みます。 - 複合書式指定文字列 (「解説」を参照)。 - 書式設定および書き込みをする 0 個以上のオブジェクトを含むオブジェクト配列。 - 文字列またはオブジェクトが null として渡されました。 - - が閉じています。 - I/O エラーが発生しました。 - - は有効な復号書式指定文字列ではありません。または 書式項目のインデックスが 0 より小さいか、 配列の長さ以上です。 - 1 - - - 4 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 4 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 8 バイト符号なし整数のテキスト形式をテキスト文字列またはストリームに書き込み、続けて行終端記号を書き込みます。 - 書き込む 8 バイト符号なし整数。 - - が閉じています。 - I/O エラーが発生しました。 - 1 - - - 行終端記号をテキスト文字列またはストリームに非同期的に書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - テキスト ストリームに書き込む文字配列。文字配列が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字の部分配列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - データの書き込み元の文字配列。 - データの取得を開始する、バッファー内の文字位置。 - 書き込む文字数。 - - は null です。 - - に を加算した値が、バッファーの長さを超えています。 - - または が負の値です。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - 文字列をテキスト文字列またはストリームに非同期的に書き込み、続けて行終端記号を書き込みます。 - 非同期の書き込み操作を表すタスク。 - 書き込む文字列。値が null の場合は、行終端記号だけが書き込まれます。 - テキスト ライターは破棄されます。 - テキスト ライターは現在、前の書き込み操作で使用中です。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml deleted file mode 100644 index 145ab498..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/ko/System.IO.xml +++ /dev/null @@ -1,2262 +0,0 @@ - - - - System.IO - - - - 기본 데이터 형식을 특정 인코딩의 이진 값으로 읽습니다. - 2 - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 가 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 하는 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 입력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - 스트림이 읽기를 지원하지 않거나 null이거나 이미 닫힌 경우 - - 또는 가 null인 경우 - - - - 의 내부 스트림에 대한 액세스를 노출합니다. - BinaryReader와 관련된 내부 스트림입니다. - 2 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 스트림에서 읽은 지정된 바이트 수로 내부 버퍼를 채웁니다. - 읽을 바이트 수입니다. - - 를 읽기 전에 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 요청된 가 내부 버퍼 크기보다 큰 경우 - - - 사용할 수 있는 다음 문자를 반환하고 바이트 또는 문자 위치를 앞으로 이동하지 않습니다. - 사용할 수 있는 다음 문자를 반환하고 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 현재 문자는 스트림에 선택한 을 사용하여 내부 문자 버퍼링으로 디코딩할 수 없습니다. - 2 - - - 내부 스트림에서 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 입력 스트림의 다음 문자를 반환하고 현재 사용할 수 있는 문자가 없을 경우 -1을 반환합니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 바이트 배열의 지정된 지점부터 스트림에서 지정된 바이트 수만큼 읽습니다. - - 로 읽어 온 바이트 수입니다.이 바이트 수는 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 문자 배열의 지정된 지점부터 스트림에서 지정된 문자 수만큼 읽습니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 문자가 현재 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 데이터를 읽어올 버퍼입니다. - 버퍼로 읽어오기를 시작할 버퍼의 시작 위치입니다. - 읽을 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 또는읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 압축 형식의 32비트 정수를 읽습니다. - 압축 형식의 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 스트림이 손상되었습니다. - - - 현재 스트림에서 Boolean 값을 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 바이트가 0이 아니면 true이고 0이면 false입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 다음 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 다음 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 지정된 바이트 수만큼 바이트 배열로 읽어 오고 현재 위치를 해당 바이트 수만큼 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 바이트 배열입니다.이 바이트 배열은 스트림의 끝에 도달할 경우 요청된 바이트 수보다 작을 수 있습니다. - 읽을 바이트 수입니다.이 값은 0 또는 음수가 아닌 숫자여야 합니다. 그렇지 않으면 예외가 발생합니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 다음 문자를 읽고 사용된 Encoding과 스트림에서 읽어오는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 현재 스트림에서 읽은 문자입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 서로게이트 문자를 읽은 경우 - 2 - - - 현재 스트림에서 지정된 문자 수만큼 읽어 문자 배열로 데이터를 반환하고, 사용된 Encoding과 스트림에서 읽어 오는 특정 문자의 길이만큼 현재 위치를 앞으로 이동합니다. - 내부 스트림에서 읽은 데이터를 포함하는 문자 배열입니다.이 문자 배열은 스트림의 끝에 도달할 경우 요청된 문자 수보다 작을 수 있습니다. - 읽을 문자 수입니다. - 읽을 수 있도록 디코딩된 문자의 수는 보다 큽니다.유니코드 디코더가 대체 문자 또는 서로게이트 쌍을 반환하는 경우 이 문제가 발생할 수 있습니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - - 가 음수인 경우 - 2 - - - 현재 스트림에서 10진 값을 읽고 스트림의 현재 위치를 16바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 10진 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 8바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 8바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 2바이트 정수를 읽고 스트림의 현재 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 4바이트 정수를 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 8바이트 정수를 읽고 스트림의 현재 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 있는 바이트를 읽고 스트림의 현재 위치를 1바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 있는 바이트입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 4바이트 부동 소수점 값을 읽고 스트림의 현재 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 4바이트 부동 소수점 값입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 문자열을 읽습니다.한 번에 7비트 정수로 인코드된 길이는 해당 문자열의 접두사로 붙습니다. - 읽어 오는 문자열입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - little-endian 인코딩을 사용하여 현재 스트림에서 부호 없는 2바이트 정수를 읽고 스트림의 위치를 2바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 2바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 4바이트 정수를 읽고 스트림의 위치를 4바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 4바이트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 스트림에서 부호 없는 8바이트 정수를 읽고 스트림의 위치를 8바이트 앞으로 이동합니다. - 현재 스트림에서 읽은 부호 없는 8바이트 정수입니다. - 스트림의 끝에 도달한 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 기본 이진 형식을 스트림에 쓰고 특정 인코딩으로 된 문자열 쓰기를 지원합니다. - 2 - - - 스트림에 쓰는 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 스트림을 기반으로 UTF-8 인코딩을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 가 null입니다. - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화합니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - 지정된 스트림과 문자 인코딩을 기반으로 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 출력 스트림입니다. - 사용할 문자 인코딩입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 그렇지 않으면 false입니다. - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - - 또는 이 null인 경우 - - - - 의 내부 스트림을 가져옵니다. - BinaryWriter와 관련된 내부 스트림입니다. - 1 - - - - 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 1 - - - 백업 저장소가 없는 를 지정합니다. - 1 - - - 내부 스트림을 보유합니다. - - - 현재 스트림 내에서 위치를 설정합니다. - 현재 스트림에서의 위치입니다. - - 에 상대적인 바이트 오프셋입니다. - 새 위치를 가져올 참조 위치를 나타내는 의 필드입니다. - 파일 포인터가 잘못된 위치로 이동한 경우 - - 값이 잘못된 경우 - 1 - - - false를 나타내는 0과 true를 나타내는 1을 사용하여 1바이트 Boolean 값을 현재 스트림에 씁니다. - 쓸 Boolean 값(0 또는 1)입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 없는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 내부 스트림에 바이트 배열을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 null입니다. - 1 - - - 현재 스트림에 바이트 배열 영역을 씁니다. - 쓸 데이터를 포함하는 바이트 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 바이트 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - - 가 단일 서로게이트 문자인 경우 - 1 - - - 문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - - 가 null입니다. - 스트림이 닫혀 있는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 쓰기를 시작할 의 시작점입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null입니다. - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다. - 출력할 10진수 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 있는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다. - 쓸 부호 있는 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부동 소수점 값입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - - 의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다. - 쓸 값입니다. - I/O 오류가 발생하는 경우 - - 가 null입니다. - 스트림이 닫혀 있는 경우 - 1 - - - 2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다. - 쓸 2바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다. - 쓸 4바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다. - 쓸 8바이트 부호 없는 정수입니다. - I/O 오류가 발생하는 경우 - 스트림이 닫혀 있는 경우 - 1 - - - 압축 형식의 32비트 정수를 씁니다. - 쓸 32비트 정수입니다. - 스트림의 끝에 도달한 경우 - 스트림이 닫혀 있는 경우 - 스트림이 닫혀 있는 경우 - - - 읽을 때 throw되는 예외가 스트림의 끝을 지나 시도됩니다. - 2 - - - 시스템에서 제공되는 메시지로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - - 로 설정된 메시지 문자열과 COR_E_ENDOFSTREAM으로 설정된 HRESULT를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - - - 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 오류를 설명하는 문자열입니다. 내용은 사용자의 이해를 돕기 위한 것입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 데이터 스트림의 형식이 잘못된 경우 throw되는 예외입니다. - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - - - 이 예외의 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 예외에 대한 이유를 설명하는 오류 메시지입니다. - 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. - - - 백업 저장소가 메모리인 스트림을 만듭니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - 0으로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 현재 스트림을 만들 부호 없는 바이트의 배열입니다. - - 가 null인 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - - 바이트 배열의 지정된 영역(인덱스)을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - - 가 null인 경우 - - 또는 가 0보다 작은 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 크기 조정이 불가능한 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 설정된 속성과 지정된 대로 설정된 호출 기능을 사용하여 지정된 바이트 배열의 영역을 기반으로 하는 클래스의 새 인스턴스를 초기화합니다. - 이 스트림을 만들 부호 없는 바이트의 배열입니다. - 스트림이 시작될 의 인덱스입니다. - 스트림의 길이(바이트)입니다. - 스트림이 쓰기를 지원하는지 여부를 결정하는 속성의 설정입니다. - 스트림을 만든 부호 없는 바이트 배열을 반환하는 를 사용하도록 설정하려면 true이고, 설정하지 않으려면 false입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - - 지정된 대로 초기화된 확장 가능한 용량을 사용하여 클래스의 새 인스턴스를 초기화합니다. - 내부 배열의 초기 크기(바이트)입니다. - - 가 음수인 경우 - - - 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 열려 있으면 true입니다. - 2 - - - 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 2 - - - 이 스트림에 할당된 바이트 수를 가져오거나 설정합니다. - 버퍼에서 스트림에 대해 사용할 수 있는 부분의 길이입니다. - 음수 또는 스트림의 현재 길이보다 작은 용량이 설정되어 있는 경우 - 현재 스트림이 닫혀 있는 경우 - 용량을 수정할 수 없는 스트림에 set이 호출되는 경우 - 2 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다. - 취소 요청을 모니터링할 토큰입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 클래스에 사용되는 관리되지 않는 리소스를 해제하고, 필요에 따라 관리되는 리소스를 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - - 메서드를 재정의하여 아무런 작업도 수행되지 않도록 합니다. - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다. - 스트림이 삭제된 경우 - - - 스트림의 길이(바이트)를 가져옵니다. - 스트림의 길이(바이트)입니다. - 스트림이 닫혀 있는 경우 - 2 - - - 스트림 내의 현재 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - 위치가 음수 값이나 보다 큰 값으로 설정된 경우 - 스트림이 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트 블록을 읽어서 버퍼에 씁니다. - 버퍼로 쓴 총 바이트 수입니다.해당 바이트 수를 현재 사용할 수 없는 경우 이 수는 요청된 바이트 수보다 작을 수 있으며 바이트를 읽기 전에 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 스트림으로부터 읽은 문자로 교체된 상태로 반환됩니다. - 현재 스트림에서 데이터를 저장하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트를 읽습니다. - - 로 캐스팅된 바이트이거나 스트림의 끝에 도달한 경우 -1입니다. - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림 내의 위치를 지정된 값으로 설정합니다. - 초기 참조 지점과 오프셋을 조합해서 계산한, 스트림 내의 새 위치입니다. - 스트림 내의 새 위치입니다.이 위치는 매개 변수와 관련되며 양수와 음수 모두 가능합니다. - 검색 참조 지점 역할을 하는 형식의 값입니다. - 스트림의 시작 전에 검색하려고 한 경우 - - 가 보다 큰 경우 - 잘못된 이 있는 경우 또는이 산술 연산 오버플로를 발생시킨 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 현재 스트림의 길이를 지정된 값으로 설정합니다. - 길이를 설정할 값입니다. - 현재 스트림의 크기를 조정할 수 없으며 가 현재 용량보다 큰 경우또는 현재 스트림이 쓰기를 지원하지 않는 경우 - - 가 음수이거나 의 최대 길이보다 큰 경우. 여기서 최대 길이는 - origin입니다. origin은 스트림이 시작되는 내부 버퍼의 인덱스입니다. - 2 - - - - 속성에 관계없이 바이트 배열에 스트림 내용을 씁니다. - 새 바이트 배열입니다. - 2 - - - 이 스트림을 만드는 데 사용된 부호 없는 바이트의 배열을 반환합니다.반환 값은 변환의 성공 여부를 나타냅니다. - 성공적으로 변환되면 true이고, 그렇지 않으면 false입니다. - 이 스트림을 만든 바이트 배열 세그먼트입니다. - - - 버퍼에서 읽은 데이터를 사용하여 현재 스트림에 바이트 블록을 씁니다. - 데이터를 쓸 버퍼입니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에서 바이트보다 가까우며 용량을 수정할 수 없는 경우 - 버퍼 길이에서 을 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 현재 스트림 인스턴스가 닫혀 있는 경우 - 2 - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 위치에서 현재 스트림에 바이트를 씁니다. - 쓸 바이트입니다. - 스트림이 쓰기를 지원하지 않습니다.자세한 내용은 를 참조하십시오.또는 현재 위치가 스트림의 끝에 있으며 용량을 수정할 수 없는 경우 - 현재 스트림이 닫혀 있는 경우 - 2 - - - 다른 스트림에 이 메모리 스트림의 전체 내용을 씁니다. - 이 메모리 스트림을 쓸 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 닫혀 있는 경우 - 2 - - - 탐색에 사용할 스트림 내 위치를 지정합니다. - 2 - - - 스트림의 맨 앞을 지정합니다. - - - 스트림 내의 현재 위치를 지정합니다. - - - 스트림의 맨 끝을 지정합니다. - - - 바이트 시퀀스에 대한 일반 뷰를 제공합니다.이 클래스는 추상 클래스입니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 파생 클래스에서 재정의되면 현재 스트림이 읽기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 읽기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림이 검색을 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 검색을 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값을 가져옵니다. - 현재 스트림이 시간 초과될 수 있는지를 결정하는 값입니다. - 2 - - - 파생 클래스에서 재정의되면 현재 스트림이 쓰기를 지원하는지를 나타내는 값을 가져옵니다. - 스트림이 쓰기를 지원하면 true이고, 지원하지 않으면 false입니다. - 1 - - - 현재 스트림에서 바이트를 읽어서 다른 스트림에 해당 바이트를 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 바이트를 읽어서 지정된 버퍼 크기로 다른 스트림에 씁니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이 읽기를 지원하지 않는 경우또는이 쓰기를 지원하지 않는 경우 - - 메서드가 호출되기 전에 현재 스트림 또는 이 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 모든 바이트를 비동기적으로 읽어 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - - 가 null인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기로 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - 현재 스트림에서 바이트를 비동기적으로 읽어 지정된 버퍼 크기 및 취소 토큰을 사용하여 다른 스트림에 씁니다. - 비동기 복사 작업을 나타내는 작업입니다. - 현재 스트림의 내용을 복사할 스트림입니다. - 버퍼의 크기(바이트)입니다.이 값은 0보다 커야 합니다.기본 크기는 81920입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 가 음수이거나 0인 경우 - 현재 스트림이나 대상 스트림이 삭제됩니다. - 현재 스트림이 읽기를 지원하지 않거나 대상 스트림이 쓰기를 지원하지 않습니다. - - - - 에서 사용하는 모든 리소스를 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의되면 이 스트림에 대해 모든 버퍼를 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 합니다. - I/O 오류가 발생하는 경우 - 2 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - 이 스트림에 대해 모든 버퍼를 비동기적으로 지우고 버퍼링된 데이터가 내부 장치에 쓰여지도록 하고 취소 요청을 모니터링합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - 스트림이 삭제된 경우 - - - 파생 클래스에서 재정의되면 스트림 바이트의 길이를 가져옵니다. - 스트림 길이(바이트)를 나타내는 long 값입니다. - Stream에서 파생된 클래스가 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 백업 저장소가 없는 Stream입니다. - 1 - - - 파생 클래스에서 재정의되면 현재 스트림 내의 위치를 가져오거나 설정합니다. - 스트림 내의 현재 위치입니다. - I/O 오류가 발생하는 경우 - 스트림이 검색을 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에서 재정의되면 현재 스트림에서 바이트의 시퀀스를 읽고, 읽은 바이트 수만큼 스트림 내에서 앞으로 이동합니다. - 버퍼로 읽어온 총 바이트 수입니다.이 바이트 수는 현재 바이트가 충분하지 않은 경우 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달하면 0이 됩니다. - 바이트 배열입니다.이 메서드가 반환될 때 버퍼에는 지정된 바이트 배열의 값이 및 ( + - 1) 사이에서 현재 원본으로부터 읽어온 바이트로 교체된 상태로 포함됩니다. - 현재 스트림에서 읽은 데이터를 저장하기 시작하는 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에서 읽을 최대 바이트 수입니다. - - 와 의 합계가 버퍼 길이보다 큰 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 현재 스트림에서 바이트 시퀀스를 읽고 읽은 바이트 수만큼 스트림에서 위치를 비동기적으로 앞으로 이동합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 현재 스트림에서 바이트의 시퀀스를 비동기적으로 읽고 읽은 바이트 수만큼 스트림 내에서 앞으로 이동하며 취소 요청을 모니터링합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 데이터를 쓸 버퍼입니다. - 스트림의 데이터를 쓰기 시작할 의 바이트 오프셋입니다. - 읽을 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 읽기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림에서 바이트를 읽고 스트림 내 위치를 한 바이트씩 앞으로 이동하거나 스트림 끝일 경우 -1을 반환합니다. - Int32로 캐스팅된 부호 없는 바이트이거나 스트림의 끝에 있는 경우 -1입니다. - 스트림이 읽기를 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 읽기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 읽기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 파생 클래스를 재정의될 때 현재 스트림 내의 위치를 설정합니다. - 현재 스트림 내의 새 위치입니다. - - 매개 변수에 상대적인 바이트 오프셋입니다. - 새 위치를 가져오는 데 사용되는 참조 위치를 나타내는 형식의 값입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우 스트림은 검색을 지원하지 않습니다. - 스트림이 닫힌 후 메서드가 호출된 경우 - 1 - - - 파생 클래스에 재정의될 때 현재 스트림의 길이를 설정합니다. - 원하는 현재 스트림의 길이(바이트)입니다. - I/O 오류가 발생하는 경우 - 예를 들어, 스트림이 파이프 또는 콘솔 출력에서 생성되는 경우처럼 스트림이 쓰기와 검색을 모두 지원하지 않는 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 파생 클래스를 재정의될 때 현재 스트림에 바이트의 시퀀스를 쓰고 쓰여진 바이트 수만큼 이 스트림 내에서 앞으로 이동합니다. - 바이트 배열입니다.이 메서드는 의 바이트를 현재 스트림으로 복사합니다. - 현재 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 현재 스트림에 쓸 바이트 수입니다. - 총  및  버퍼 길이 보다 큽니다. - - null입니다. - - 또는  음수입니다. - 지정된 된 파일을 찾을 수 없는 같은 I/O 오류가 발생 합니다. - 스트림이 쓰기를 지원하지 않습니다. - - 스트림이 닫힌 후 호출 되었습니다. - 1 - - - 현재 스트림에 바이트 시퀀스를 비동기적으로 쓰고 쓴 바이트 수만큼 이 스트림에서 현재 위치를 앞으로 이동합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 바이트의 시퀀스를 현재 스트림에 비동기적으로 쓰고 쓰여진 바이트 수만큼 이 스트림 내의 현재 위치를 앞으로 이동한 후 취소 요청을 모니터링합니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 데이터를 쓸 버퍼입니다. - 스트림으로 바이트를 복사하기 시작할 의 바이트 오프셋(0부터 시작)입니다. - 쓸 최대 바이트 수입니다. - 취소 요청을 모니터링할 토큰입니다.기본값은 입니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 쓰기를 지원하지 않습니다. - 스트림이 삭제된 경우 - 이전 쓰기 작업에서 현재 스트림을 사용하고 있습니다. - - - 스트림의 현재 위치에 바이트를 쓰고 스트림 내 위치를 1바이트씩 앞으로 이동합니다. - 스트림에 쓸 바이트입니다. - I/O 오류가 발생하는 경우 - 스트림이 쓰기를 지원하지 않거나 이미 닫힌 경우 - 스트림이 닫힌 후 메서드가 호출된 경우 - 2 - - - 스트림이 시간 초과 전 쓰기를 시도할 기간을 결정하는 값(밀리초)을 가져오거나 설정합니다. - 스트림 쓰기 시도가 만료되기 전까지 기다릴 시간을 결정하는 값(밀리초 단위)입니다. - - 메서드는 항상 을 throw합니다. - 2 - - - 특정 인코딩의 바이트 스트림에서 문자를 읽는 를 구현합니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 Reference Source. - 1 - - - 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정한 바이트 순서 표시 검색 옵션을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 가 null인 경우 - - - 지정된 문자 인코딩을 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션을 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - - 이 읽기를 지원하지 않는 경우 - - 또는 가 null인 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 사용하여 특정 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾을지 여부를 나타냅니다. - 최소 버퍼 크기입니다. - 스트림이 읽기를 지원하지 않습니다. - - 또는 가 null인 경우 - - 가 0보다 작거나 같은 경우 - - - 지정된 문자 인코딩과 바이트 순서 표시 검색 옵션, 버퍼 크기를 기반으로 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화하고 스트림을 선택적으로 연 상태로 둡니다. - 읽을 스트림입니다. - 사용할 문자 인코딩입니다. - 파일의 시작 부분에서 바이트 순서 표시를 찾으려면 true이고, 찾지 않으려면 false입니다. - 최소 버퍼 크기입니다. - - 개체를 삭제한 후 스트림을 열어 두려면 true이고, 닫으려면 false입니다. - - - 내부 스트림을 반환합니다. - 내부 스트림입니다. - 2 - - - 현재 개체에서 사용 중인 현재 문자 인코딩을 가져옵니다. - 현재 판독기에서 사용하는 문자 인코딩입니다. 메서드를 처음으로 호출할 때 인코딩이 자동으로 검색되므로 의 메서드를 처음으로 호출하면 값이 달라질 수 있습니다. - 2 - - - 내부 버퍼를 지웁니다. - 2 - - - 내부 스트림을 닫고 에서 사용하는 관리되지 않는 리소스를 해제하고 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 현재 스트림 위치가 스트림의 끝에 있는지를 나타내는 값을 가져옵니다. - 현재 스트림 위치가 스트림의 끝에 있으면 true이고, 없으면 false입니다. - 내부 스트림이 삭제된 경우 - 1 - - - 빈 스트림 주위의 개체입니다. - 1 - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 읽을 문자가 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 입력 스트림에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - - 개체로 표시되는 입력 스트림의 다음 문자이거나, 사용할 수 있는 문자가 더 이상 없는 경우에는 -1입니다. - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 지정된 최대 문자를 지정된 인덱스부터 버퍼로 읽어 들입니다. - 읽은 문자 수를 반환하거나 스트림의 끝에 있고 읽은 데이터가 없으면 0을 반환합니다.이 수는 스트림 내에서 데이터를 사용할 수 있는지 여부에 따라 매개 변수보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 인덱스입니다. - 읽을 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 가 null인 경우 - - 또는 가 음수인 경우 - 스트림이 닫히는 등의 I/O 오류가 발생한 경우 - 1 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드는 지정된 문자 배열의 값이 및 () 사이에서 현재 원본으로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - - 현재 스트림에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 스트림의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 스트림의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 스트림에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 입력 스트림의 다음 줄을 반환하거나 입력 스트림의 끝에 도달한 경우 null을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 스트림에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 스트림의 다음 줄을 포함하거나 모든 문자를 읽은 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 스트림 끝까지의 모든 문자를 읽습니다. - 현재 위치부터 끝까지의 나머지 스트림은 문자열입니다.현재 위치가 스트림 끝에 있으면 빈 문자열("")을 반환합니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 위치부터 스트림 끝까지의 모든 문자를 비동기적으로 읽어서 이를 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 스트림 끝까지 있는 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 스트림이 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - - 를 구현하여 특정 인코딩의 스트림에 문자를 씁니다.이 형식에 대 한.NET Framework 소스 코드를 찾아보려면 참조는 참조 원본. - 1 - - - UTF-8 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대해 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - - 에 쓸 수 없는 경우 - - 가 null인 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - - 또는 가 null인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화합니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - 지정된 인코딩과 기본 버퍼 크기를 사용하여 지정된 스트림에 대한 클래스의 새 인스턴스를 초기화하며, 선택적으로 스트림을 연 상태로 둘 수 있습니다. - 쓸 스트림입니다. - 사용할 문자 인코딩입니다. - 버퍼 크기(바이트)입니다. - true to leave the stream open after the object is disposed; otherwise, false. - - 또는 가 null인 경우 - - 가 음수인 경우 - - 에 쓸 수 없는 경우 - - - - 가 를 호출할 때마다 해당 버퍼를 내부 스트림에 플러시할지 여부를 나타내는 값을 가져오거나 설정합니다. - - 가 해당 버퍼를 플러시하게 하려면 true이고, 그렇지 않으면 false입니다. - 1 - - - 백업 저장소의 인터페이스 역할을 하는 내부 스트림을 가져옵니다. - 이 StreamWriter가 쓰고 있는 스트림입니다. - 2 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - - - 출력이 쓰여질 을 가져옵니다. - 현재 인스턴스에 대해 생성자에 지정된 이거나, 인코딩이 지정되지 않은 경우 입니다. - 2 - - - 현재 writer의 모든 버퍼를 지우면 버퍼링된 모든 데이터가 내부 스트림에 쓰여집니다. - 현재 writer가 닫힌 경우 - I/O 오류가 발생한 경우 - 현재 인코딩으로 유니코드 서로게이트 쌍의 한 쪽을 표시할 수 없는 경우 - 1 - - - 이 스트림에 대한 모든 버퍼를 비동기적으로 지우고 버퍼링된 모든 데이터가 내부 장치에 비동기적으로 쓰여지도록 합니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 스트림이 삭제된 경우 - - - StreamWriter에 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 제공하지 않습니다. - 1 - - - 스트림에 문자를 씁니다. - 스트림에 쓸 문자입니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자의 하위 배열을 씁니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - I/O 오류가 발생하는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - 1 - - - 스트림에 문자열을 씁니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - - 가 true이거나 버퍼가 꽉 차 있고, 현재 작성기가 닫혀 있는 경우 - - 가 true이거나 버퍼가 꽉 차 있고, 가 스트림 끝에 있기 때문에 버퍼 내용을 내부 고정 크기 스트림에 쓸 수 없는 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터를 포함하는 문자 배열입니다. - 데이터 읽기를 시작할 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열을 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자열입니다.가 null이면 아무 것도 쓰여지지 않습니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 줄 종결자를 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 스트림에 쓸 문자입니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 문자 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 스트림 작성기가 삭제됩니다. - 이전 쓰기 작업에서 현재 스트림 작성기를 사용하고 있습니다. - - - 문자열에서 읽어오는 를 구현합니다. - 2 - - - 지정된 문자열에서 읽어오는 클래스의 새 인스턴스를 초기화합니다. - - 가 초기화되어야 하는 문자열입니다. - - 매개 변수가 null인 경우 - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 사용할 수 있는 다음 문자를 반환하지만 사용하지는 않습니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 스트림에서 검색을 지원하지 않을 경우 -1입니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 내부 문자열의 다음 문자를 반환하거나, 사용할 수 있는 문자가 더 이상 없으면 -1을 반환합니다. - 현재 판독기가 닫힌 경우 - 2 - - - 입력 문자열에서 문자 블록을 읽은 다음 문자 위치를 씩 앞으로 이동합니다. - 버퍼로 읽어온 총 문자 수입니다.이 문자 수는 현재 문자가 충분하지 않은 경우 요청된 문자 수보다 작을 수 있으며 내부 문자열의 끝에 도달하면 0이 됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 버퍼의 시작 인덱스입니다. - 읽을 문자 수입니다. - - 가 null입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 지정된 최대 수의 문자를 비동기적으로 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 문자열의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼에 기록하기 전에 문자열의 끝에 도달하면 메서드가 반환됩니다. - - 가 null입니다. - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 문자열에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 현재 문자열의 다음 줄 또는 문자열의 끝에 도달한 경우 null입니다. - 현재 판독기가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 2 - - - 현재 문자열에서 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 문자열 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치부터 문자열 끝까지의 모든 문자를 읽어서 이를 단일 문자열로 반환합니다. - 내부 문자열의 현재 위치에서 끝까지의 내용입니다. - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 현재 판독기가 닫힌 경우 - 2 - - - 현재 위치부터 문자열 끝까지의 모든 문자를 비동기적으로 읽어서 이를 단일 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 문자열 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 문자열 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 정보를 문자열로 쓰기 위한 를 구현합니다.정보는 내부 에 저장됩니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정한 형식 제어를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 형식 지정을 제어하는 개체입니다. - - - 지정한 에 쓰는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - - 가 null입니다. - - - 지정한 에 쓰고 지정한 서식 공급자를 갖는 클래스의 새 인스턴스를 초기화합니다. - 작성할 StringBuilder입니다. - 형식 지정을 제어하는 개체입니다. - - 가 null입니다. - - - - 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 출력이 쓰여질 을 가져옵니다. - 출력이 쓰여질 Encoding입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터가 내부 장치에 쓰여집니다. - 비동기 플러시 작업을 나타내는 작업입니다. - - - 내부 를 반환합니다. - 내부 StringBuilder입니다. - 2 - - - 현재 StringWriter에 지금까지 쓰여진 문자가 포함된 문자열을 반환합니다. - 현재 StringWriter에 쓰여진 문자가 포함된 문자열입니다. - 2 - - - 문자를 문자열에 씁니다. - 쓸 문자입니다. - 작성기가 닫힌 경우 - 2 - - - 문자의 하위 배열을 문자열에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 또는 가 음수인 경우 - ( + )> 인 경우Length. - 작성기가 닫힌 경우 - 2 - - - 문자를 현재 문자열에 씁니다. - 쓸 문자열입니다. - 작성기가 닫힌 경우 - 2 - - - 문자를 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자를 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰여지지 않습니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 문자열에 쓸 문자입니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 읽기를 시작하는 버퍼의 위치입니다. - 쓸 최대 문자 수입니다. - - 가 null입니다. - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 현재 문자열에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 쓰여집니다. - 문자열 작성기가 삭제됩니다. - 이전 쓰기 작업에서 문자열 작성기를 현재 사용하고 있습니다. - - - 여러 개의 문자를 순차적으로 읽을 수 있는 판독기를 나타냅니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - TextReader에 읽을 데이터를 제공하지 않습니다. - 1 - - - 문자 소스나 판독기의 상태를 변경하지 않고 다음 문자를 읽습니다.판독기에서 실제로 읽지 않고 사용 가능한 다음 문자를 반환합니다. - 읽을 다음 문자를 나타내는 정수이거나, 사용할 수 있는 문자가 더 이상 없거나 판독기에서 검색을 지원하지 않을 경우 -1입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 텍스트 판독기에서 다음 문자를 읽고 문자 위치를 한 문자씩 앞으로 이동합니다. - 텍스트 판독기의 다음 문자 또는 사용할 수 있는 문자가 더 이상 없는 경우 -1입니다.기본 구현된 경우에는 -1을 반환합니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 판독기 내에서 데이터를 사용할 수 있는지 여부에 따라 보다 작거나 같습니다.읽을 문자가 더 이상 없는 경우에 이 메서드를 호출하면 0이 반환됩니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 판독기의 끝에 도달하면 메서드가 반환됩니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 텍스트 판독기에서 지정된 최대 수의 문자를 읽어 이 데이터를 지정된 인덱스에서 시작되는 버퍼에 씁니다. - 읽은 문자 수입니다.이 문자 수는 모든 입력 문자를 읽었는지 여부에 따라 보다 작거나 같습니다. - 이 메서드가 반환할 때 이 매개 변수에는 지정된 문자 배열의 값이 및 ( + -1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 들어 있습니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다. - - 가 null인 경우 - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 2 - - - 현재 텍스트 판독기에서 지정된 최대 문자 수를 비동기적으로 읽어 이 데이터를 지정된 위치에서 시작되는 버퍼에 씁니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 버퍼 안으로 읽어들인 총 바이트 수를 포함합니다.현재 사용할 수 있는 바이트 수가 요청된 수보다 작을 경우 결과 값이 요청된 바이트 수보다 작을 수 있으며 텍스트의 끝에 도달한 경우에는 0이 될 수도 있습니다. - 이 메서드는 지정된 문자 배열의 값이 및 ( + - 1) 사이에서 현재 소스로부터 읽어온 문자로 교체된 상태로 반환됩니다. - 쓰기를 시작할 의 위치입니다. - 읽을 최대 문자 수입니다.지정한 문자 수를 버퍼로 읽어오기 전에 텍스트의 끝에 도달하면 현재 메서드가 반환됩니다. - - 가 null인 경우 - - 또는 가 음수인 경우 - - 와 의 합계가 버퍼 길이보다 큰 경우 - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 텍스트 판독기에서 한 줄의 문자를 읽고 데이터를 문자열로 반환합니다. - 판독기의 다음 줄이거나 모든 문자를 읽은 경우 null입니다. - I/O 오류가 발생하는 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - - 가 닫힌 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 한 줄의 문자를 비동기적으로 읽고 데이터를 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 텍스트 판독기의 다음 줄을 포함하거나 모든 문자가 읽혀진 경우에는 null입니다. - 다음 줄의 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 읽어서 단일 문자열로 반환합니다. - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 포함하는 문자열입니다. - I/O 오류가 발생하는 경우 - - 가 닫힌 경우 - 반환된 문자열을 위한 버퍼를 할당할 메모리가 부족한 경우 - 다음 줄의 문자 수가 보다 큰 경우 - 1 - - - 현재 위치에서 텍스트 판독기 끝까지의 모든 문자를 비동기적으로 읽어서 하나의 문자열로 반환합니다. - 비동기 읽기 작업을 나타내는 작업입니다. 매개 변수의 값은 현재 위치에서 텍스트 판독기 끝까지의 문자로 이루어진 문자열을 포함합니다. - 문자 수가 보다 큽니다. - 텍스트 판독기가 삭제된 경우 - 이전 읽기 작업에서 판독기를 현재 사용하고 있습니다. - - - 일련의 문자를 연속하여 쓸 수 있는 작성기를 나타냅니다.이 클래스는 추상 클래스입니다. - 2 - - - - 클래스의 새 인스턴스를 초기화합니다. - - - 지정된 서식 공급자를 사용하여 클래스의 새 인스턴스를 초기화합니다. - 서식 지정을 제어하는 개체입니다. - - - 이 TextWriter에 사용한 줄 바꿈 문자를 저장합니다. - - - 해당 개체에서 사용하는 리소스를 모두 해제합니다. - - - - 가 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. - 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. - - - 파생 클래스에서 재정의된 경우 출력을 쓰는 문자 인코딩을 반환합니다. - 출력을 쓰는 문자 인코딩입니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 1 - - - 현재 작성기에 대한 모든 버퍼를 비동기적으로 지우면 버퍼링된 모든 데이터를 내부 장치에 씁니다. - 비동기 플러시 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 작성기를 현재 사용하고 있습니다. - - - 서식 지정을 제어하는 개체를 가져옵니다. - 특정 문화권에 대한 개체이거나, 다른 문화권을 지정하지 않은 경우 현재 문화권의 서식입니다. - 2 - - - 현재 TextWriter에서 사용한 줄 종결자 문자열을 가져오거나 설정합니다. - 현재 TextWriter의 줄 종결자 문자열입니다. - 2 - - - 쓸 수는 있지만 읽을 수는 없는 백업 저장소를 TextWriter에 제공하지 않습니다. - 1 - - - Boolean 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자 배열을 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - - 또는 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현을 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.가 null이면 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열을 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.가 null이면 텍스트 스트림에 아무 것도 쓰지 않습니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 줄 종결자를 텍스트 문자열 또는 스트림에 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - Boolean 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 Boolean 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 텍스트 스트림에 쓸 문자입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 데이터를 읽을 문자 배열입니다. - 데이터 읽기를 시작하는 의 문자 위치입니다. - 쓸 최대 문자 수입니다. - 버퍼 길이에서 를 빼면 보다 작은 경우 - - 매개 변수가 null인 경우 - - 또는 가 음수인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 10진수 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 10진수 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 8바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 8바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 있는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 있는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 개체에 대해 ToString 메서드를 호출하여 해당 개체의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 개체입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 4바이트 부동 소수점 값의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 4바이트 부동 소수점 값입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 문자열입니다.가 null이면 줄 종결자만 씁니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 1입니다. - 1 - - - - 메서드와 동일한 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 텍스트 문자열이나 스트림에 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 2입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 첫 번째 개체입니다. - 서식을 지정하고 쓸 두 번째 개체입니다. - 서식을 지정하고 쓸 세 번째 개체입니다. - - 가 null인 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 형식 항목의 인덱스가 0보다 작거나, 형식을 지정할 개체의 수보다 크거나 같은 경우입니다. 즉, 이 메서드 오버로드의 경우는 3입니다. - 1 - - - - 과 같은 의미 체계를 사용하여 서식이 지정된 문자열과 새 줄을 씁니다. - 합성 형식 문자열입니다(설명 부분 참조). - 서식을 지정하고 쓸 개체를 0개 이상 포함하는 개체 배열입니다. - 문자열이나 개체가 null로 전달되는 경우 - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - - 이 유효한 합성 서식 문자열이 아닙니다.또는 서식 항목의 인덱스가 0보다 작거나 배열의 길이보다 크거나 같습니다. - 1 - - - 부호 없는 4바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 4바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 부호 없는 8바이트 정수의 텍스트 표현과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 씁니다. - 쓸 부호 없는 8바이트 정수입니다. - - 가 닫힌 경우 - I/O 오류가 발생하는 경우 - 1 - - - 줄 종결자를 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자와 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자입니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 텍스트 스트림에 쓸 문자 배열입니다.문자 배열이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자의 하위 배열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 데이터가 있는 문자 배열입니다. - 데이터 검색을 시작하는 버퍼의 문자 위치입니다. - 쓸 문자 수입니다. - - 가 null인 경우 - - 와 의 합이 버퍼 길이보다 큽니다. - - 또는 가 음수인 경우 - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - 문자열과 줄 종결자를 차례로 텍스트 문자열 또는 스트림에 비동기적으로 씁니다. - 비동기 쓰기 작업을 나타내는 작업입니다. - 쓸 문자열입니다.값이 null이면 줄 종결자만 씁니다. - 텍스트 작성기가 삭제됩니다. - 이전 쓰기 작업에서 텍스트 작성기를 현재 사용하고 있습니다. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml deleted file mode 100644 index d9ad6103..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/ru/System.IO.xml +++ /dev/null @@ -1,2023 +0,0 @@ - - - - System.IO - - - - Считывает примитивные типы данных как двоичные значения в заданной кодировке. - 2 - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Входной поток. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов. - Входной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса на основе указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Входной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает чтение, имеет значение null или был закрыт до начала операции. - Параметр или имеет значение null. - - - Предоставляет доступ к базовому потоку объекта . - Базовый поток, связанный с объектом BinaryReader. - 2 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Заполняет внутренний буфер указанным количеством байтов, которые были cчитаны из потока. - Количество байтов, чтение которых необходимо выполнить. - Конец потока достигнут раньше, чем было выполнено чтение байтов. - Ошибка ввода-вывода. - Запрошенное значение превышает размер внутреннего буфера. - - - Возвращает следующий доступный для чтения символ, не перемещая позицию байта или символа вперед. - Следующий доступный символ или значение -1, если в потоке больше нет символов, или поток не поддерживает поиск. - Ошибка ввода-вывода. - Текущий символ не может быт декодирован в буфер внутренних символов с помощью , выбранного для потока. - 2 - - - Выполняет чтение знаков из базового потока и перемещает текущую позицию в потоке вперед в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Следующий символ из входного потока или значение -1, если в настоящее время доступных символов нет. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Считывает указанное количество байтов из потока, начиная с заданной точки в массиве байтов. - Количество байтов, считанных в .Количество символов может быть меньше указанного числа, если в потоке осталось меньше байтов, чем следует считать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Количество байтов, чтение которых необходимо выполнить. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество символов из потока, начиная с заданной точки в массиве символов. - Общее количество символов, считанных в буфер.Количество символов может быть меньше указанного числа, если в потоке осталось меньше символов, чем следует прочитать. Количество символов также может равняться нулю, если достигнут конец потока. - Буфер, в который должны считываться данные. - Стартовая точка в буфере, начиная с которой считываемые данные записываются в буфер. - Число символов для чтения. - Длина буфера за вычетом значения параметра меньше значения параметра . -или-Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число в сжатом формате. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Поток поврежден. - - - Считывает значение Boolean из текущего потока и перемещает текущую позицию в потоке на один байт вперед. - Значение true, если байт не равен нулю; в противном случае — значение false. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока следующий байт и перемещает текущую позицию в потоке на один байт вперед. - Следующий байт, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает указанное количество байтов из текущего потока в массив байтов и перемещает текущую позицию на это количество байтов. - Массив байтов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных байтов. - Количество байтов, чтение которых необходимо выполнить.Это значение должно быть равно 0 или быть больше 0, иначе возникнет исключение. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Ошибка ввода-вывода. - Поток закрыт. - Значение отрицательно. - 2 - - - Считывает следующий знак из текущего потока и изменяет текущую позицию в потоке в соответствии с используемым значением Encoding и конкретным знаком в потоке, чтение которого выполняется в настоящий момент. - Символ, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - Выполнено чтение символа-заместителя. - 2 - - - Считывает указанное количество символов из текущего потока, возвращает данные в массив символов и перемещает текущую позицию в соответствии с используемой Encoding и определенным символом, считываемым из потока. - Массив символов, в котором содержатся данные, считанные из базового потока.Если при чтении был достигнут конец потока, это число может быть меньше, чем количество запрошенных символов. - Количество символов, которое необходимо считать. - Число декодированных знаков для чтения больше, чем .Это может произойти, если декодер Юникода возвращает резервные символы или суррогатную пару. - Поток закрыт. - Ошибка ввода-вывода. - Значение отрицательно. - 2 - - - Считывает десятичное значение из текущего потока и перемещает текущую позицию в потоке на шестнадцать байтов вперед. - Десятичное значение, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Число с плавающей запятой длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 2 байта из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число со знаком длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число со знаком длиной 8 байта из текущего потока и перемещает текущую позицию в потоке на восемь байт вперед. - Целое число со знаком длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает из текущего потока байт со знаком и перемещает текущую позицию в потоке на один байт вперед. - Байт со знаком, считанный из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает число с плавающей запятой длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Число с плавающей запятой длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает строку из текущего потока.Строка предваряется значением длины строки, которое закодировано как целое число блоками по семь битов. - Считываемая строка. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 2 байта в формате с прямым порядком байтов из текущего потока и перемещает текущую позицию в потоке на два байта вперед. - Целое число без знака длиной 2 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 4 байта из текущего потока и перемещает текущую позицию в потоке на четыре байта вперед. - Целое число без знака длиной 4 байта, считанное из текущего потока. - Достигнут конец потока. - Поток закрыт. - Ошибка ввода-вывода. - 2 - - - Считывает целое число без знака длиной 8 байт из текущего потока и перемещает текущую позицию в потоке на восемь байтов вперед. - Целое число без знака длиной 8 байт, считанное из текущего потока. - Достигнут конец потока. - Ошибка ввода-вывода. - Поток закрыт. - 2 - - - Записывает простые типы данных в поток как двоичные значения и поддерживает запись строк в определенной кодировке. - 2 - - - Выполняет инициализацию нового экземпляра класса , который осуществляет запись в поток. - - - Инициализирует новый экземпляр класса на основании указанного потока с использованием кодировки UTF-8. - Выходной поток. - Поток не поддерживает запись или был закрыт до начала операции. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов. - Выходной поток. - Кодировка символов, которую нужно использовать. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Инициализирует новый экземпляр класса на основании указанного потока и кодировки символов, а также при необходимости оставляет поток открытым. - Выходной поток. - Кодировка символов, которую нужно использовать. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Поток не поддерживает запись или был закрыт до начала операции. - Значение параметра или — null. - - - Получает базовый поток . - Базовый поток, связанный с объектом BinaryWriter. - 1 - - - Освобождает все ресурсы, используемые текущим экземпляром класса . - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Задает без резервного хранилища. - 1 - - - Содержит базовый поток. - - - Задает позицию в текущем потоке. - Позиция в текущем потоке. - Смещение в байтах относительно . - Поле указывает точку отсчета, относительно которой указывается новая позиция. - Указатель позиции в файле перемещен в недопустимую позицию. - Значение является недопустимым. - 1 - - - Выполняет запись значения типа Boolean длиной один байт в текущий поток, при этом 0 соответствует значению false, а 1 — значению true. - Записываемое в поток значение типа Boolean (0 или 1). - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись байта без знака в текущий поток и перемещает позицию в потоке на один байт вперед. - Записываемый в поток байт без знака. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись массива байтов в базовый поток. - Массив байтов, содержащий записываемые в поток данные. - Ошибка ввода-вывода. - Поток закрыт. - Параметр имеет значение null. - 1 - - - Выполняет запись части массива байтов в текущий поток. - Массив байтов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество записываемых байтов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Выполняет запись символа Юникод в текущий поток и перемещает текущую позицию в потоке вперед в соответствии с используемой Encoding и количеством записанных в поток символов. - Незаменяющий символ Юникода, который необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - - представляет собой единичный символ-заместитель. - 1 - - - Выполняет запись массива символов в текущий поток и перемещает текущую позицию в потоке в соответствии с используемой Encoding и количеством записанных в поток символов. - Массив символов, содержащий записываемые в поток данные. - Параметр имеет значение null. - Поток закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись части массива символов в текущий поток и изменяет текущую позицию в потоке в соответствии с используемой Encoding и, возможно, количеством символов, записанных в поток. - Массив символов, содержащий записываемые в поток данные. - Стартовая точка в буфере , с которой начинается запись. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает десятичное число в текущий поток и перемещает позицию в потоке на шестнадцать байтов. - Десятичное значение, которое необходимо записать. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Число с плавающей запятой длиной 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число со знаком размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число со знаком размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число со знаком длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число со знаком размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает байт со знаком в текущий поток и перемещает позицию в потоке вперед на один байт. - Байт со знаком, который необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает число с плавающей запятой длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Число с плавающей запятой длиной 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает в текущий поток строку, предваряемую ее длиной, используя текущую кодировку , и перемещает позицию в потоке вперед в соответствии с используемой кодировкой и количеством записанных в поток символов. - Записываемое значение. - Ошибка ввода-вывода. - Параметр имеет значение null. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 2 байта в текущий поток и перемещает позицию в потоке вперед на два байта. - Целое число без знака размером 2 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 4 байта в текущий поток и перемещает позицию в потоке вперед на четыре байта. - Целое число без знака размером 4 байта, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает целое число без знака длиной 8 байт в текущий поток и перемещает позицию в потоке вперед на восемь байт. - Целое число без знака размером 8 байт, которое необходимо записать в поток. - Ошибка ввода-вывода. - Поток закрыт. - 1 - - - Записывает 32-разрядное целое число в сжатом формате. - 32-разрядное целое число, которое необходимо записать. - Достигнут конец потока. - Поток закрыт. - Поток закрыт. - - - Исключение, которое создается при попытке выполнить чтение за пределами потока. - 2 - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке системного сообщения, и значением HRESULT равным COR_E_ENDOFSTREAM. - - - Выполняет инициализацию нового экземпляра класса со строкой сообщения, которая соответствует строке , и значением HRESULT равным COR_E_ENDOFSTREAM. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - - - Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, которое стало причиной данного исключения. - Строка, описывающая ошибку.Содержимое параметра должно быть понятным пользователю.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Исключение возникает, когда поток данных имеет недопустимый формат. - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным сообщением об ошибке. - Сообщение об ошибке с объяснением причин исключения. - - - Инициализирует новый экземпляр класса со ссылкой на внутреннее исключение, которое является причиной данного исключения. - Сообщение об ошибке с объяснением причин исключения. - Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. - - - Создает поток, резервным хранилищем которого является память.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной нулевым значением. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов. - Массив байтов без знака, из которого создается текущий поток. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанного массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области (индекса) массива байтов. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Свойство имеет значение null. - Значение параметра или меньше нуля. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый неизменяемый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства . - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Свойство имеет значение null. - Параметр или имеет отрицательное значение. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса на основе указанной области массива байтов с помощью указанного значения свойства и возможности вызова с указанным значением. - Массив байтов без знака, из которого создается данный поток. - Индекс в , с которого начинается поток. - Длина потока в байтах. - Параметр свойства , который определяет возможность поддержки потоком записи. - Значение true, чтобы разрешить метод , возвращающий массив байтов без знака, из которого создан поток; в противном случае — значение false. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом значения параметра меньше значения параметра . - - - Инициализирует новый экземпляр класса расширяемой емкостью, инициализированной с указанным значением. - Исходный размер внутреннего массива в байтах. - Значение отрицательно. - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций чтения. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций поиска. - Значение true, если поток открыт. - 2 - - - Возвращает значение, определяющее в текущем потоке наличие поддержки операций записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 2 - - - Возвращает или задает число байтов, выделенных для этого потока. - Длина применимой к использованию части буфера для потока. - Заданная емкость отрицательная или меньше текущей длины потока. - Текущий поток закрыт. - set вызывается для потока, емкость которого нельзя изменить. - 2 - - - Асинхронно считывает все байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля. - Токен для отслеживания запросов отмены. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает неуправляемые ресурсы, используемые классом (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Переопределяет метод так, что никакие действия не выполняются. - 2 - - - Асинхронно очищает все буферы для этого потока и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены. - Поток был ликвидирован. - - - Возвращает длину потока в байтах. - Длина потока в байтах. - Поток закрыт. - 2 - - - Возвращает или задает текущее положение в потоке. - Текущее положение в потоке. - В качестве положения задано отрицательное значение или значение, большее . - Поток закрыт. - 2 - - - Считывает блок байтов из текущего потока и записывает данные в буфер. - Общее число байтов, записанных в буфер.Оно может быть меньше запрошенного числа байтов, если это количество в текущий момент не доступно, или же равно нулю, если конец потока достигнут до того, как байты были считаны. - При возвращении данного метода этот параметр содержит указанный массив байтов со значениями от до ( + - 1), замененными символами, считанными из текущего потока. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается сохранение данных из текущего потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Длина буфера за вычетом меньше, чем . - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из текущего потока. - Байт приводится к типу или -1, если достигнут конец потока. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для положения в текущем потоке. - Новое положение в потоке, вычисляемое путем объединения смещения и исходной точки ссылки. - Новое положение в потоке.Оно определяется относительно параметра и может быть положительным или отрицательным. - Значение типа , которое действует как точка ссылки поиска. - Попытка поиска выполняется до начала потока. - Значение больше значения . - - недопустим. -или-Значение вызвало арифметическое переполнение. - Текущий экземпляр потока закрыт. - 2 - - - Задает указанное значение для длины текущего потока. - Значение задаваемой длины. - Размер текущего потока изменить нельзя, и значение параметра больше текущей емкости.-или- Текущий поток не поддерживает запись. - Значение параметра отрицательное или больше максимальной длины , где максимальная длина равна ( - источник). Источник — это индекс в основном буфере, с которого начинается поток. - 2 - - - Записывает содержимое потока в массив байтов независимо от свойства . - Новый массив байтов. - 2 - - - Возвращает массив байтов без знака, из которого был создан данный поток.Возвращаемое значение указывает, успешно ли выполнено преобразование. - Значение true, если преобразование прошло успешно; в противном случае — значение false. - Сегмент массива байтов, из которого был создан данный поток. - - - Записывает в текущий поток блок байтов, используя данные, считанные из буфера. - Буфер, из которого записываются данные. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение ближе к концу потока, чем число байтов , и емкость изменить невозможно. - Длина буфера за вычетом меньше, чем . - Параметр или имеет отрицательное значение. - Ошибка ввода-вывода. - Текущий экземпляр потока закрыт. - 2 - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение текущего потока. - Записываемый байт. - Поток не поддерживает запись.Дополнительные сведения см. в разделе .-или- Текущее положение находится в конце потока и емкость изменить невозможно. - Текущий поток закрыт. - 2 - - - Записывает все содержимое данного потока памяти в другой поток. - Поток, в который требуется осуществить запись данного потока памяти. - Свойство имеет значение null. - Текущий или конечный поток закрыт. - 2 - - - Задает позицию в потоке, используемую для поиска. - 2 - - - Задает начало потока. - - - Задает текущее положение в потоке. - - - Задает конец потока. - - - Предоставляет универсальное представление последовательности байтов.Этот класс является абстрактным.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 2 - - - Инициализирует новый экземпляр класса . - - - При переопределении в производном классе возвращает значение, показывающее, поддерживает ли текущий поток возможность чтения. - Значение true, если поток поддерживает чтение; в противном случае — значение false. - 1 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживается ли в текущем потоке возможность поиска. - Значение true, если поток поддерживает поиск; в противном случае — значение false. - 1 - - - Возвращает значение, которое показывает, может ли для данного потока истечь время ожидания. - Значение, которое показывает, может ли для данного потока истечь время ожидания. - 2 - - - При переопределении в производном классе возвращает значение, которое показывает, поддерживает ли текущий поток возможность записи. - Значение true, если поток поддерживает запись; в противном случае — значение false. - 1 - - - Считывает байты из текущего потока и записывает их в другой поток. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Поток, в который будет скопировано содержимое текущего потока. - Размер буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток не поддерживает чтение.-или-Параметр не поддерживает запись. - Текущий поток или параметр был закрыт до вызова метода . - Произошла ошибка ввода-вывода. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Свойство имеет значение null. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Асинхронно считывает байты из текущего потока и записывает их в другой поток, используя указанный размер буфера и токен отмены. - Задача, представляющая асинхронную операцию копирования. - Поток, в который будет скопировано содержимое текущего потока. - Размер (в байтах) буфера.Это значение должно быть больше нуля.Размер по умолчанию — 81920. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Параметр имеет отрицательное значение или равен нулю. - Текущий поток или поток назначения удаляется. - Текущий поток не поддерживает чтение или поток назначения не поддерживает запись. - - - Освобождает все ресурсы, занятые модулем . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе очищает все буферы данного потока и вызывает запись данных буферов в базовое устройство. - Ошибка ввода-вывода. - 2 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Асинхронно очищает все буферы данного потока, вызывает запись буферизованных данных в базовое устройство и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию очистки. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Поток был ликвидирован. - - - При переопределении в производном классе получает длину потока в байтах. - Длинное значение, представляющее длину потока в байтах. - Класс, созданный на основе класса Stream, не поддерживает возможность поиска. - Методы были вызваны после закрытия потока. - 1 - - - Объект Stream без резервного хранилища. - 1 - - - При переопределении в производном классе получает или задает позицию в текущем потоке. - Текущее положение в потоке. - Ошибка ввода-вывода. - Этот поток не поддерживает поиск. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе считывает последовательность байтов из текущего потока и перемещает позицию в потоке на число считанных байтов. - Общее количество байтов, считанных в буфер.Это число может быть меньше количества запрошенных байтов, если столько байтов в настоящее время недоступно, а также равняться нулю (0), если был достигнут конец потока. - Массив байтов.После завершения выполнения данного метода буфер содержит указанный массив байтов, в котором значения в интервале между и ( + - 1) заменены байтами, считанными из текущего источника. - Смещение байтов (начиная с нуля) в , с которого начинается сохранение данных, считанных из текущего потока. - Максимальное количество байтов, которое должно быть считано из текущего потока. - Сумма значений параметров и больше длины буфера. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 1 - - - Асинхронно считывает последовательность байтов из текущего потока и перемещает позицию внутри потока на число считанных байтов. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает последовательность байтов из текущего потока, перемещает позицию в потоке на число считанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - Буфер, в который записываются данные. - Смещение байтов в , с которого начинается запись данных из потока. - Максимальное число байтов, предназначенных для чтения. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает чтение. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией чтения. - - - Считывает байт из потока и перемещает позицию в потоке на один байт или возвращает -1, если достигнут конец потока. - Байт без знака, приведенный к Int32, или значение -1, если достигнут конец потока. - Поток не поддерживает чтение. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию чтения, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - При переопределении в производном классе задает позицию в текущем потоке. - Новая позиция в текущем потоке. - Смещение в байтах относительно параметра . - Значение типа , указывающее точку ссылки, которая используется для получения новой позиции. - Ошибка ввода-вывода. - Поток не поддерживает поиск, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 1 - - - При переопределении в производном классе задает длину текущего потока. - Нужная длина текущего потока в байтах. - Ошибка ввода-вывода. - Поток не поддерживает ни поиск, ни запись, например, если поток создан на основе канала или вывода консоли. - Методы были вызваны после закрытия потока. - 2 - - - При переопределении в производном классе записывает последовательность байтов в текущий поток и перемещает текущую позицию в нем вперед на число записанных байтов. - Массив байтов.Этот метод копирует байты из в текущий поток. - Отсчитываемое от нуля смещение байтов в буфере , с которого начинается копирование байтов в текущий поток. - Количество байтов, которое необходимо записать в текущий поток. - Сумма  и  больше, чем длина буфера. - - — null. - - или  является отрицательным. - Произошла ошибка ввода-вывода, такие как не удается найти указанный файл. - Поток не поддерживает запись. - - был вызван после закрытия потока. - 1 - - - Асинхронно записывает последовательность байтов в текущий поток и перемещает текущую позицию внутри потока на число записанных байтов. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает последовательность байтов в текущий поток, перемещает текущую позицию внутри потока на число записанных байтов и отслеживает запросы отмены. - Задача, представляющая асинхронную операцию записи. - Буфер, из которого записываются данные. - Смещение байтов (начиная с нуля) в объекте , с которого начинается копирование байтов в поток. - Максимальное число байтов для записи. - Токен для отслеживания запросов отмены.Значение по умолчанию — . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток не поддерживает запись. - Поток был ликвидирован. - Поток в настоящее время используется предыдущей операцией записи. - - - Записывает байт в текущее положение в потоке и перемещает позицию в потоке вперед на один байт. - Байт, записываемый в поток. - Ошибка ввода-вывода. - Поток не поддерживает запись или был закрыт до начала операции. - Методы были вызваны после закрытия потока. - 2 - - - Возвращает или задает значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Значение в миллисекундах, определяющее период, в течение которого поток будет пытаться выполнить операцию записи, прежде чем истечет время ожидания. - Метод всегда создает исключение . - 2 - - - Реализует объект , который считывает символы из потока байтов в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. Reference Source. - 1 - - - Инициализирует новый экземпляр класса для заданного потока. - Поток, который нужно считать. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданный параметр обнаружения метки порядка следования байтов. - Поток, который нужно считать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Свойство имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов и параметр обнаружения метки порядка байтов. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - - не поддерживает чтение. - Параметр или имеет значение null. - - - Инициализирует новый экземпляр класса для заданного потока, используя указанную кодировку символов, параметр обнаружения метки порядка байтов и размер буфера. - Поток, который нужно считать. - Кодировка символов, которую нужно использовать. - Указывает, следует ли выполнять поиск меток порядка байтов с начала файла. - Минимальный размер буфера. - Поток не поддерживает чтение. - Параметр или имеет значение null. - Значение параметра меньше или равно нулю. - - - Инициализирует новый экземпляр класса для указанного потока на основе заданной кодировки символов, параметра обнаружения меток порядка байтов и размера буфера, а также при необходимости оставляет поток открытым. - Считываемый поток. - Кодировка символов, которую нужно использовать. - Значение true для поиска меток порядка байтов в начале файла; в противном случае — значение false. - Минимальный размер буфера. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - - - Возвращает основной поток. - Основной поток. - 2 - - - Возвращает текущую кодировку символов, используемую текущим объектом . - Текущая кодировка символов, используемая текущим устройством чтения.После первого вызова любого метода объекта значение может измениться, поскольку до первого вызова метода автоматическое определение кодировки не выполняется. - 2 - - - Очищает внутренний буфер. - 2 - - - Закрывает основной поток, освобождает неуправляемые ресурсы, используемые , и при необходимости освобождает управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Возвращает значение, определяющее, находится ли позиция текущего потока в конце потока. - Значение true, если текущее положение находится в конце потока; в противном случае — значение false. - Основной поток удален. - 1 - - - Объект для пустого потока. - 1 - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ для прочтения или значение -1, если доступных для чтения символов нет или поток не поддерживает поиск. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из входного потока и перемещает положение символа на одну позицию вперед. - Следующий символ из входного потока, представленный в виде объекта , или значение -1, если больше нет доступных символов. - Ошибка ввода-вывода. - 1 - - - Считывает заданное максимальное количество символов из текущего потока в буфер начиная с заданного индекса. - Число символов, которые были считаны, или значение 0, если к концу потока не было считано никаких данных.Это число будет не больше параметра , в зависимости от доступности данных в потоке. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Индекс , с которого требуется начать запись. - Максимальное число считываемых символов. - Длина буфера за вычетом значения параметра меньше значения параметра . - Свойство имеет значение null. - Значение параметра или является отрицательным. - Возникает ошибка ввода-вывода, например закрывается поток. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем указанное количество символов записывается в буфер, возвращается текущий метод. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению , в зависимости от того, считаны ли все входящие символы. - При возврате данный метод содержит указанный массив символов, в котором значения в интервале между и () заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Произошла ошибка ввода-вывода. - - - Асинхронно считывает указанное максимальное количество символов из текущего потока и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число доступных в данный момент байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец потока. - При возвращении из этого метода содержит указанный массив символов, в котором значения в интервале от и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец потока достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Следующая строка из входного потока или значение null, если достигнут конец входного потока. - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно выполняет чтение строки символов из текущего потока и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из потока или значение null, если все знаки прочитаны. - Количество символов в следующей строке больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца потока. - Остальная часть потока в виде строки (от текущего положения до конца).Если текущее положение находится в конце потока, возвращается пустая строка (""). - Недостаточно памяти для размещения буфера возвращаемых строк. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца потока, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца потока. - Количество символов больше . - Поток был ликвидирован. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи символов в поток в определенной кодировке.Чтобы просмотреть исходный код .NET Framework для этого типа, см. ссылки на источник. - 1 - - - Инициализирует новый экземпляр класса для указанного потока, используя кодировку UTF-8 и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Запись в поток запрещена. - - is null. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера по умолчанию. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Значение параметра или — null. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Инициализирует новый экземпляр класса для указанного потока, используя заданную кодировку и размер буфера, а также при необходимости оставляет поток открытым. - Поток, в который требуется выполнить запись. - Кодировка символов, которую нужно использовать. - Размер буфера в байтах. - Значение true, чтобы оставить поток открытым после удаления объекта ; в противном случае — значение false. - Значение параметра или — null. - Значение отрицательно. - Запись в поток запрещена. - - - Получает или задает значение, определяющее, будет ли сбрасывать буфер в основной поток после каждого вызова . - Значение true, чтобы заставить сбросить буфер; в противном случае — false. - 1 - - - Получает основной поток, связанный с резервным хранилищем. - Поток, в который StreamWriter выполняет запись. - 2 - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - trueЧтобы освободить управляемые и неуправляемые ресурсы; false чтобы освободить только неуправляемые ресурсы. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Кодировка , указанная в конструкторе для текущего экземпляра, или , если кодировка не задана. - 2 - - - Очищает все буферы для текущего средства записи и вызывает запись всех данных буфера в основной поток. - Текущее средство записи закрывается. - Произошла ошибка ввода-вывода. - Текущая кодировка не поддерживает отображение половины суррогатной пары Юникода. - 1 - - - Асинхронно очищает все буферы для этого потока и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Поток был ликвидирован. - - - Предоставляет StreamWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает символ в поток. - Символ, записываемый в поток. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток массив символов. - Массив символов, содержащий записываемые в поток данные.Если имеет значение null, запись не выполняется. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток дочерний массив символов. - Массив символов, содержащий записываемые данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Ошибка ввода-вывода. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - 1 - - - Записывает в поток строку. - Строка, записываемая в поток.Если равняется null, запись не выполняется. - - имеет значение True, или буфер полон, и текущее средство записи закрывается. - - имеет значение True, или буфер полон, и его содержимое не может быть записано в основной поток заданного размера, поскольку находится в конце потока. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает символ в поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, содержащий записываемые данные. - Положение символа в буфере с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает строку в поток. - Задача, представляющая асинхронную операцию записи. - Строка, записываемая в поток.Если имеет значение null, запись не выполняется. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток признак конца строки. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в поток. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - - is null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи потока. - Средство записи потока в настоящее время используется предыдущей операцией записи. - - - Реализует класс , осуществляющий чтение из строки. - 2 - - - Инициализирует новый экземпляр класса , осуществляющий чтение из указанной строки. - Строка, для которой должен быть инициализирован класс . - Значение параметра — null. - - - Освобождает неуправляемые ресурсы, используемые (при необходимости освобождает и управляемые ресурсы). - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Возвращает следующий доступный символ, но не использует его. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или поток не поддерживает поиск. - Текущее средство чтения закрыто. - 2 - - - Считывает следующий символ из строки ввода и увеличивает позицию символа на один символ. - Следующий символ из основной строки или значение -1, если больше нет доступных символов. - Текущее средство чтения закрыто. - 2 - - - Считывает блок символов из строки ввода и увеличивает позицию символов на . - Общее количество символов, считанных в буфер.Оно может быть меньше, чем число запрошенных символов, если большинство символов не доступно в текущий момент, или равно нулю, если достигнут конец основной строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Начальный индекс в буфере. - Количество символов, которые необходимо считать. - Параметр имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Асинхронно считывает указанное максимальное количество символов из текущей строки и записывает данные в буфер, начиная с заданного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец строки. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Наибольшее число символов для чтения.Если конец строки достигнут, прежде чем в буфер записано указанное количество символов, метод возвращает управление. - Параметр имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Следующая строка из текущей строки, или значение null, если достигнут конец строки. - Текущее средство чтения закрыто. - Недостаточно памяти для размещения буфера возвращаемых строк. - 2 - - - Асинхронно выполняет чтение строки символов из текущей строки и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения строк или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение всех символов, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Содержимое, начиная от текущей позиции до конца основной строки. - Недостаточно памяти для размещения буфера возвращаемых строк. - Текущее средство чтения закрыто. - 2 - - - Асинхронно считывает все символы, начиная с текущей позиции до конца строки, и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца строки. - Количество символов больше . - Удалено средство чтения строки. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Реализует для записи данных в строку.Данные хранятся в основном . - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса с указанным форматом объекта. - Объект , управляющий форматированием. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс . - Класс StringBuilder, в который осуществляется запись. - Параметр имеет значение null. - - - Инициализирует новый экземпляр класса , с помощью которого осуществляется запись в указанный класс и который имеет указанный формат поставщика. - Класс StringBuilder, в который осуществляется запись. - Объект , управляющий форматированием. - Параметр имеет значение null. - - - Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . - Значение true позволяет освободить управляемые и неуправляемые ресурсы; значение false позволяет освободить только неуправляемые ресурсы. - - - Получает кодировку , в которой осуществляется запись выходных данных. - Encoding, в которой осуществляется запись выходных данных. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - - - Возвращает основной . - Базовый StringBuilder. - 2 - - - Возвращает строку, содержащую символы, записанные до этого момента в текущий StringWriter. - Строка, содержащая символы, записанные в текущий StringWriter. - 2 - - - Записывает символ в строку. - Символ для записи. - Средство записи закрыто. - 2 - - - Записывает в строку дочерний массив символов. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Значение параметра или является отрицательным. - ( + )> .Length. - Средство записи закрыто. - 2 - - - Записывает строку в текущую строку. - Строка для записи. - Средство записи закрыто. - 2 - - - Выполняет асинхронную запись символа в строку. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в строку. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текущую строку. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего записано не будет. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в строку символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в строку. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в строку дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение в буфере, с которого начинается чтение данных. - Наибольшее количество символов для записи. - Параметр имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Асинхронного записывает в текущий поток строку, за которой следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак завершения строки. - Удалено средство записи строки. - Средство записи строки в настоящее время используется предыдущей операцией записи. - - - Представляет средство чтения, позволяющее считывать последовательные наборы символов. - 2 - - - Инициализирует новый экземпляр класса . - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также и управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - Предоставляет TextReader без данных, доступных для чтения. - 1 - - - Выполняет чтение следующего символа, не изменяя состояние средства чтения или источника символа.Возвращает следующий доступный символ, фактически не считывая его из средства чтения. - Целое число, представляющее следующий символ, чтение которого необходимо выполнить, или значение -1, если доступных символов больше нет или средство чтения не поддерживает поиск. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет чтение следующего символа из средства чтения текста и перемещает положение символа на одну позицию вперед. - Следующий символ из средства чтения текста или значение -1, если доступных символов больше нет.Реализация по умолчанию возвращает значение -1. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Считывает указанное максимальное количество символов из текущего средства чтения и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Количество будет меньше или равно в зависимости от доступности данных в средстве чтения.Этот метод возвращает 0 (нуль), если его вызвать при отсутствии символов, доступных для чтения. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец средства чтения достигнут, прежде чем в буфер считано указанное количество символов, метод возвращает управление. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с заданного индекса. - Количество считанных символов.Число будет меньше или равно значению в зависимости от того, считаны ли все входящие символы. - При возвращении данного метода этот параметр содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов. - Свойство имеет значение null. - Длина буфера за вычетом значения параметра меньше значения параметра . - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 2 - - - Асинхронно считывает указанное максимальное количество символов из текущего средства чтения текста и записывает данные в буфер, начиная с указанного индекса. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит общее число байтов, считанных в буфер.Значение результата может быть меньше запрошенного числа байтов, если число текущих доступных байтов меньше запрошенного числа, или результат может быть равен 0 (нулю), если был достигнут конец текста. - При возвращении данного метода содержит заданный массив символов, в котором значения в интервале между и ( + - 1) заменены символами, считанными из текущего источника. - Позиция в буфере , с которого начинается запись. - Максимальное число считываемых символов.Если конец текста достигнут, прежде чем указанное количество символов считывается в буфер, текущий метод возвращает управление. - Свойство имеет значение null. - Значение параметра или является отрицательным. - Сумма значений параметров и больше длины буфера. - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Выполняет чтение строки символов из средства чтения текста и возвращает данные в виде строки. - Следующая строка из средства чтения, или значение null, если все символы считаны. - Ошибка ввода-вывода. - Недостаточно памяти для размещения буфера возвращаемых строк. - Объект закрыт. - Количество символов в следующей строке больше . - 1 - - - Асинхронно выполняет чтение строки символов и возвращает данные в виде строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит следующую строку из средства чтения текста или значение null, если все знаки считаны. - Количество символов в следующей строке больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Считывает все символы, начиная с текущей позиции до конца средства чтения текста, и возвращает их в виде одной строки. - Строка, содержащая все символы, начиная с текущей позиции до конца средства чтения текста. - Ошибка ввода-вывода. - Объект закрыт. - Недостаточно памяти для размещения буфера возвращаемых строк. - Количество символов в следующей строке больше . - 1 - - - Асинхронно считывает все символы с текущей позиции до конца средства чтения текста и возвращает их в виде одной строки. - Задача, представляющая асинхронную операцию чтения.Значение параметра содержит строку с символами от текущего положения до конца средства чтения текста. - Количество символов больше . - Удалено средство чтения текста. - Средство чтения в настоящее время используется предыдущей операцией чтения. - - - Представляет модуль записи, который может записывать последовательные наборы символов.Это абстрактный класс. - 2 - - - Инициализирует новый экземпляр класса . - - - Инициализирует новый экземпляр класса указанным поставщиком формата. - Объект , управляющий форматированием. - - - Сохраняет символы новой строки, используемые для данного TextWriter. - - - Освобождает все ресурсы, используемые объектом . - - - Освобождает неуправляемые ресурсы, используемые объектом , а при необходимости освобождает также управляемые ресурсы. - Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. - - - При переопределении в производном классе возвращает кодировку символов, в которой записаны выходные данные. - Кодировка символов, в которой осуществляется запись выходных данных. - 1 - - - Очищает все буферы текущего модуля записи и вызывает немедленную запись всех буферизованных данных на базовое устройство. - 1 - - - Асинхронно очищает все буферы текущего средства записи и вызывает запись всех буферизованных данных в базовое устройство. - Задача, представляющая асинхронную операцию очистки. - Удалено средство записи текста. - Средство записи в настоящее время используется предыдущей операцией записи. - - - Возвращает объект, управляющий форматированием. - Объект для указанного языка и региональных параметров или форматирование текущего языка и региональных параметров, если не заданы другие. - 2 - - - Возвращает или задает признак конца строки, используемой текущим TextWriter. - Признак конца строки для текущего TextWriter. - 2 - - - Предоставляет TextWriter без резервного хранилища, в который можно осуществлять запись, но из которого нельзя считывать данные. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись символа в текстовую строку или поток. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет запись массива символов в текстовую строку или поток. - Массив символов, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает дочерний массив символов в текстовую строку или поток. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает текстовое представление десятичного значения в текстовую строку или поток. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байт. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта с помощью вызова метода ToString для этого объекта. - Записываемый объект. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает строку в текстовую строку или поток. - Строка для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает форматированную строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Параметр или имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Выполняет асинхронную запись символа в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись массива символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если имеет значение null, запись не выполняется. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает дочерний массив символов в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Выполняет асинхронную запись строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если параметр имеет значение null, в текстовый поток ничего не записывается. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Записывает признак конца строки в текстовую строку или поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения Boolean, за которым следует признак конца строки. - Значение Boolean для записи. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Символ, записываемый в текстовый поток. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Массив символов, из которого считываются данные. - Положение символа в , с которого начинается чтение данных. - Наибольшее количество символов для записи. - Длина буфера за вычетом значения параметра меньше значения параметра . - Параметр имеет значение null. - Значение параметра или является отрицательным. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление десятичного значения, за которым следует признак конца строки. - Десятичное значение, которое необходимо записать. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 8 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 4 байта, за которым следует признак конца строки. - Записываемое целое число со знаком размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа со знаком размером 8 байт, за которым следует признак конца строки. - Записываемое целое число со знаком размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление объекта путем вызова метода ToString для этого объекта, за которым следует признак конца строки. - Записываемый объект.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление значения с плавающей запятой размером 4 байта, за которым следует признак конца строки. - Записываемое значение с плавающей запятой размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток строку, за которой следует признак конца строки. - Строка для записи.Если имеет значение null, записывается только признак конца строки. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 1). - 1 - - - Записывает форматированную строку и новую строку в текстовую строку или поток, используя ту же семантику, что и метод . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 2). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Первый объект для форматирования и записи. - Второй объект для форматирования и записи. - Третий объект для форматирования и записи. - Свойство имеет значение null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля) или больше или равен числу объектов, которые необходимо отформатировать (которое для этой перегрузки метода равно 3). - 1 - - - Записывает отформатированную строку и новую строку, используя ту же семантику, что и . - Строка составного формата (см. примечания). - Массив объектов, содержащий от нуля и более объектов, которые необходимо форматировать и записать. - Строка или объект передаются в виде null. - Объект закрыт. - Ошибка ввода-вывода. - Параметр не является допустимой строкой составного формата.-или- Индекс элемента формата меньше 0 (нуля), либо больше или равен длине массива . - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 4 байта, за которым следует признак конца строки. - Записываемое целое число без знака размером 4 байта. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Записывает в текстовую строку или поток текстовое представление целого числа без знака размером 8 байт, за которым следует признак конца строки. - Записываемое целое число без знака размером 8 байт. - Объект закрыт. - Ошибка ввода-вывода. - 1 - - - Асинхронно записывает признак конца строки в текстовую строку или поток. - Задача, представляющая асинхронную операцию записи. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток символ, за которым следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Символ, записываемый в текстовый поток. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, записываемый в текстовый поток.Если массив символов имеет значение null, записывается только признак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток дочерний массив символов, за которыми следует признак конца строки. - Задача, представляющая асинхронную операцию записи. - Массив символов, из которого записываются данные. - Положение символа в буфере, с которого начинается извлечение данных. - Количество символов для записи. - Свойство имеет значение null. - Сумма значений параметров и превышает длину буфера. - Значение параметра или является отрицательным. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - Асинхронно записывает в текстовую строку или поток строку, за которой следует знак конца строки. - Задача, представляющая асинхронную операцию записи. - Строка для записи.Если значение равно null, записывается только знак конца строки. - Удалено средство записи текста. - Средство записи текста в настоящее время используется предыдущей операцией записи. - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml deleted file mode 100644 index cf7eb52f..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hans/System.IO.xml +++ /dev/null @@ -1,2237 +0,0 @@ - - - - System.IO - - - - 用特定的编码将基元数据类型读作二进制值。 - 2 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输入流。 - 该流不支持读取，为null 或已关闭。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输入流。 - 要使用的字符编码。 - 该流不支持读取，为null 或已关闭。 - - 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输入流。 - 要使用的字符编码。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - 该流不支持读取，为null 或已关闭。 - - 或 为 null。 - - - 公开对 的基础流的访问。 - 与 BinaryReader 关联的基础流。 - 2 - - - 释放 类的当前实例所使用的所有资源。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 用从流中读取的指定字节数填充内部缓冲区。 - 要读取的字节数。 - 在可以读取 之前到达了流的末尾。 - 发生 I/O 错误。 - 请求的 大于内部缓冲区大小。 - - - 返回下一个可用的字符，并且不提升字节或字符的位置。 - 下一个可用的字符，或者，如果没有可用字符或者流不支持查找时为 -1。 - 发生 I/O 错误。 - 当前字符无法通过使用为该流选择的 解码到内部字符缓冲区中。 - 2 - - - 从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 输入流中的下一个字符，如果当前无可用字符则为 -1。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 从字节数组中的指定点开始，从流中读取指定的字节数。 - 读入 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字节数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从字符数组中的指定点开始，从流中读取指定的字符数。 - 读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。 - 将数据读入的缓冲区。 - 缓冲区中的起始点，在该处开始读入缓冲区。 - 要读取的字符数。 - 缓冲区长度减去 小于 。- 或 -要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - - 为 null。 - - 或 为负。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 以压缩格式读入 32 位整数。 - 压缩格式的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 流已损坏。 - - - 从当前流中读取 Boolean 值，并使该流的当前位置提升 1 个字节。 - 如果字节为非零，则为 true，否则为 false。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取下一个字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的下一个字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取指定的字节数以写入字节数组中，并将当前位置前移相应的字节数。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字节数组可能小于所请求的字节数。 - 要读取的字节数。此值必须为 0 或非负数字，否则将出现异常。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 发生 I/O 错误。 - 流已关闭。 - - 为负数。 - 2 - - - 从当前流中读取下一个字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。 - 从当前流中读取的字符。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 读取了一个代理项字符。 - 2 - - - 从当前流中读取指定的字符数，并以字符数组的形式返回数据，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。 - 包含从基础流中读取的数据的字节数组。如果到达了流的末尾，则该字符数组可能小于所请求的字符数。 - 要读取的字符数。 - 要读取的解码字符数大于 。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。 - 流已关闭。 - 发生 I/O 错误。 - - 为负数。 - 2 - - - 从当前流中读取十进制数值，并将该流的当前位置提升十六个字节。 - 从当前流中读取的十进制数值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节浮点值，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 2 字节有符号整数，并使流的当前位置提升 2 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节有符号整数，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 2 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节有符号整数，并使流的当前位置提升 8 个字节。 - 从当前流中读取的 8 字节有符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从此流中读取 1 个有符号字节，并使流的当前位置提升 1 个字节。 - 从当前流中读取的一个有符号字节。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节浮点值，并使流的当前位置提升 4 个字节。 - 从当前流中读取的 4 字节浮点值。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取一个字符串。字符串有长度前缀，一次 7 位地被编码为整数。 - 正被读取的字符串。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 使用 Little-Endian 编码从当前流中读取 2 字节无符号整数，并将流的位置提升 2 个字节。 - 从该流中读取的 2 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 4 字节无符号整数并使流的当前位置提升 4 个字节。 - 从该流中读取的 4 字节无符号整数。 - 已到达流的末尾。 - 流已关闭。 - 发生 I/O 错误。 - 2 - - - 从当前流中读取 8 字节无符号整数并使流的当前位置提升 8 个字节。 - 从该流中读取的 8 字节无符号整数。 - 已到达流的末尾。 - 发生 I/O 错误。 - 流已关闭。 - 2 - - - 以二进制形式将基元类型写入流，并支持用特定的编码写入字符串。 - 2 - - - 初始化向流中写入的 类的新实例。 - - - 基于所指定的流和特定的 UTF-8 编码，初始化 类的新实例。 - 输出流。 - 该流不支持写入或者该流已关闭。 - - 为 null。 - - - 基于所指定的流和特定的字符编码，初始化 类的新实例。 - 输出流。 - 要使用的字符编码。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 基于所提供的流和特定的字符编码，初始化 类的新实例，有选择性的打开流。 - 输出流。 - 要使用的字符编码。 - 如果在释放 对象之后打开流对象，则为 true；否则为， false。 - 该流不支持写入或者该流已关闭。 - - 或 为 null。 - - - 获取 的基础流。 - 与 BinaryWriter 关联的基础流。 - 1 - - - 释放由 类的当前实例占用的所有资源。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 指定无后备存储区的 。 - 1 - - - 持有基础流。 - - - 设置当前流中的位置。 - 包含当前流的位置。 - 相对于 的字节偏移量。 - - 的一个字段，指示获取新位置所依据的参考点。 - 文件指针被移到无效位置。 - - 值无效。 - 1 - - - 将单字节 Boolean 值写入当前流，其中 0 表示 false，1 表示 true。 - 要写入的 Boolean 值（0 或 1）。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个无符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的无符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将字节数组写入基础流。 - 包含要写入的数据的字节数组。 - 发生 I/O 错误。 - 流已关闭。 - - 为 null。 - 1 - - - 将字节数组部分写入当前流。 - 包含要写入的数据的字节数组。 - - 中开始写入的起始点。 - 要写入的字节数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 Unicode 字符写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 要写入的非代理项 Unicode 字符。 - 发生 I/O 错误。 - 流已关闭。 - - 是单一代理项字符。 - 1 - - - 将字符数组写入当前流，并根据所使用的 Encoding 和向流中写入的特定字符，提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 为 null。 - 流已关闭。 - 发生 I/O 错误。 - 1 - - - 将字符数组部分写入当前流，并根据所使用的 Encoding（可能还根据向流中写入的特定字符），提升流的当前位置。 - 包含要写入的数据的字符数组。 - - 中开始写入的起始点。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个十进制值写入当前流，并将流位置提升十六个字节。 - 要写入的十进制值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节浮点值写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 2 字节有符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节有符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节有符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节有符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将一个有符号字节写入当前流，并将流的位置提升 1 个字节。 - 要写入的有符号字节。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节浮点值写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节浮点值。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将有长度前缀的字符串按 的当前编码写入此流，并根据所使用的编码和写入流的特定字符，提升流的当前位置。 - 要写入的值。 - 发生 I/O 错误。 - - 为 null。 - 流已关闭。 - 1 - - - 将 2 字节无符号整数写入当前流，并将流的位置提升 2 个字节。 - 要写入的 2 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 4 字节无符号整数写入当前流，并将流的位置提升 4 个字节。 - 要写入的 4 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 将 8 字节无符号整数写入当前流，并将流的位置提升 8 个字节。 - 要写入的 8 字节无符号整数。 - 发生 I/O 错误。 - 流已关闭。 - 1 - - - 以压缩格式写出 32 位整数。 - 要写出的 32 位整数。 - 已到达流的末尾。 - 流已关闭。 - 流已关闭。 - - - 读操作试图超出流的末尾时引发的异常。 - 2 - - - 初始化 类的新实例，将其消息字符串设置为系统提供的消息，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - - - 初始化 类的新实例，使其消息字符串设置为 ，其 HRESULT 设置为 COR_E_ENDOFSTREAM。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - - - 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 - 描述错误的字符串。 的内容被设计为人可理解的形式。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 在数据流的格式无效时引发的异常。 - - - 初始化 类的新实例。 - - - 使用指定的错误消息初始化 类的新实例。 - 解释异常原因的错误信息。 - - - 用对作为此异常原因的内部异常的引用初始化 类的新实例。 - 解释异常原因的错误信息。 - 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 - - - 创建一个流，其后备存储为内存。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化为零的可扩展容量初始化 类的新实例。 - - - 基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建当前流的无符号字节数组。 - - 为 null。 - - - 在 属性按指定设置的状态下，基于指定的字节数组初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - - 基于字节数组的指定区域（索引）初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 为 null。 - - 或 小于零。 - 缓冲区长度减去 小于 。 - - - 在 属性按指定设置的状态下，基于字节数组的指定区域，初始化 类的无法调整大小的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 在 属性和调用 的能力按指定设置的状态下，基于字节数组的指定区域初始化 类的新实例。 - 从中创建此流的无符号字节的数组。 - - 内的索引，流从此处开始。 - 流的长度（以字节为单位）。 - - 属性的设置，确定该流是否支持写入。 - 设置为 true 可以启用 ，它返回无符号字节数组，流从该数组创建；否则为 false。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 小于 。 - - - 使用按指定要求初始化的可扩展容量初始化 类的新实例。 - 内部数组的初始大小（以字节为单位）。 - - 为负数。 - - - 获取一个值，该值指示当前流是否支持读取。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持查找。 - 如果流是打开的，则为 true。 - 2 - - - 获取一个值，该值指示当前流是否支持写入。 - 如果流支持写入，则为 true；否则为 false。 - 2 - - - 获取或设置分配给该流的字节数。 - 流的缓冲区的可使用部分的长度。 - 容量设置为负或小于流的当前长度。 - 当前流已关闭。 - 对不能修改其容量的流调用 set。 - 2 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取所有字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。 - 要监视取消请求的标记。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放 类使用的非托管资源，并可以选择释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 重写 方法以便不执行任何操作。 - 2 - - - 异步清除此流的所有缓冲区，并监视取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。 - 流已被释放。 - - - 获取流的长度（以字节为单位）。 - 流的长度（以字节为单位）。 - 流已关闭。 - 2 - - - 获取或设置流中的当前位置。 - 流中的当前位置。 - 此位置设置为负值或大于 的值。 - 流已关闭。 - 2 - - - 从当前流中读取字节块并将数据写入缓冲区。 - 写入缓冲区中的总字节数。如果字节数当前不可用，则总字节数可能小于所请求的字节数；如果在读取到任何字节前已到达流结尾，则为零。 - 当此方法返回时，包含指定的字节数组，该数组中从 到 ( + -1) 之间的值由从当前流中读取的字符替换。 - - 中的从零开始的字节偏移量，从此处开始存储当前流中的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - 缓冲区长度减去 的结果小于 。 - 当前流实例已关闭。 - 2 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流中读取一个字节。 - 强制转换为 的字节；或者如果已到达流的末尾，则为 -1。 - 当前流实例已关闭。 - 2 - - - 将当前流中的位置设置为指定值。 - 流内的新位置，通过将初始引用点和偏移量合并计算而得。 - 流内的新位置。它是相对于 参数的位置，而且可正可负。 - 类型 的值，它用作查找引用点。 - 试图在流的开始位置之前查找。 - - 大于 。 - - 无效。- 或 - 导致算法溢出。 - 当前流实例已关闭。 - 2 - - - 将当前流的长度设为指定值。 - 用于设置长度的值。 - 当前流无法调整大小，而且 大于当前容量。- 或 - 当前流不支持写入。 - - 为负或者大于 的最大长度，其中最大长度为 (- origin)，origin 为基础缓冲区中作为流的起点的索引。 - 2 - - - 将流内容写入字节数组，而与 属性无关。 - 新的字节数组。 - 2 - - - 返回从中创建此流的无符号字节的数组。用于指示转换是否成功的返回值。 - 如果转换成功，则为 true；否则为 false。 - 用于创建此流的字节数组段。 - - - 使用从缓冲区读取的数据将字节块写入当前流。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 最多写入的字节数。 - - 为 null。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置到流结尾的距离小于 字节，并且无法修改容量。 - 缓冲区长度减去 的结果小于 。 - - 或 为负。 - 发生 I/O 错误。 - 当前流实例已关闭。 - 2 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入当前位置上的当前流。 - 要写入的字节。 - 流不支持写入。有关其他信息，请参见 。- 或 - 当前位置位于流的末尾，而且容量不能被修改。 - 当前流已关闭。 - 2 - - - 将此内存流的整个内容写入到另一个流中。 - 要写入此内存流的流。 - - 为 null。 - 当前流或目标流已关闭。 - 2 - - - 指定在流的位置以查找使用。 - 2 - - - 指定流的开头。 - - - 指定流内的当前位置。 - - - 指定流的结尾。 - - - 提供字节序列的一般视图。这是一个抽象类。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 类的新实例。 - - - 当在派生类中重写时，获取指示当前流是否支持读取的值。 - 如果流支持读取，为 true；否则为 false。 - 1 - - - 当在派生类中重写时，获取指示当前流是否支持查找功能的值。 - 如果流支持查找，为 true；否则为 false。 - 1 - - - 获取一个值，该值确定当前流是否可以超时。 - 一个确定当前流是否可以超时的值。 - 2 - - - 当在派生类中重写时，获取指示当前流是否支持写入功能的值。 - 如果流支持写入，则为 true；否则为 false。 - 1 - - - 从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 使用指定的缓冲区大小，从当前流中读取字节并将其写入到另一流中。 - 当前流的内容将复制到的流。 - 缓冲区的大小。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流不支持读取。- 或 - 不支持写入。 - 在调用 方法前当前流或 已关闭。 - 发生了 I/O 错误。 - - - 从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - - 为 null。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小，从当前流中异步读取字节并将其写入到另一流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 使用指定的缓冲区大小和取消令牌，从当前流中异步读取字节并将其写入到另一个流中。 - 表示异步复制操作的任务。 - 当前流的内容将复制到的流。 - 缓冲区的大小（以字节为单位）。此值必须大于零。默认大小为 81920。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 为负数或零。 - 当前流或目标流已释放。 - 当前流不支持阅读，或目标流不支持写入。 - - - 释放由 使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，将清除该流的所有缓冲区，并使得所有缓冲数据被写入到基础设备。 - 发生 I/O 错误。 - 2 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 异步清理这个流的所有缓冲区，并使所有缓冲数据写入基础设备，并且监控取消请求。 - 表示异步刷新操作的任务。 - 要监视取消请求的标记。默认值为 。 - 流已被释放。 - - - 当在派生类中重写时，获取流长度（以字节为单位）。 - 表示流长度（以字节为单位）的长值。 - 从 Stream 派生的类不支持查找。 - 在流关闭后调用方法。 - 1 - - - 无后备存储区的 Stream。 - 1 - - - 当在派生类中重写时，获取或设置当前流中的位置。 - 流中的当前位置。 - 发生 I/O 错误。 - 流不支持查找。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，从当前流读取字节序列，并将此流中的位置提升读取的字节数。 - 读入缓冲区中的总字节数。如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 - 字节数组。此方法返回时，该缓冲区包含指定的字符数组，该数组的 和 ( + -1) 之间的值由从当前源中读取的字节替换。 - - 中的从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 - 要从当前流中最多读取的字节数。 - - 与 的和大于缓冲区长度。 - - 为 null。 - - 或 为负。 - 发生 I/O 错误。 - 流不支持读取。 - 在流关闭后调用方法。 - 1 - - - 从当前流异步读取字节序列，并将流中的位置提升读取的字节数。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从当前流异步读取字节的序列，将流中的位置提升读取的字节数，并监视取消请求。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 数据写入的缓冲区。 - - 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 - 最多读取的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持读取。 - 流已被释放。 - 该流正在由其前一次读取操作使用。 - - - 从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。 - 强制转换为 Int32 的无符号字节，如果到达流的末尾，则为 -1。 - 流不支持读取。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试读取多长时间。 - 一个确定流在超时前尝试读取多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 当在派生类中重写时，设置当前流中的位置。 - 当前流中的新位置。 - 相对于 参数的字节偏移量。 - - 类型的值，指示用于获取新位置的参考点。 - 发生 I/O 错误。 - 流不支持查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 1 - - - 当在派生类中重写时，设置当前流的长度。 - 所需的当前流的长度（以字节表示）。 - 发生 I/O 错误。 - 流不支持写入和查找，例如在流通过管道或控制台输出构造的情况下即为如此。 - 在流关闭后调用方法。 - 2 - - - 当在派生类中重写时，向当前流中写入字节序列，并将此流中的当前位置提升写入的字节数。 - 字节数组。此方法将 个字节从 复制到当前流。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 - 要写入当前流的字节数。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 流不支持写入。 - - 流关闭后调用。 - 1 - - - 将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将字节的序列异步写入当前流，将该流中的当前位置向前移动写入的字节数，并监视取消请求。 - 表示异步写入操作的任务。 - 从中写入数据的缓冲区。 - - 中的从零开始的字节偏移量，从此处开始将字节复制到该流。 - 最多写入的字节数。 - 要监视取消请求的标记。默认值为 。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流不支持写入。 - 流已被释放。 - 该流正在由其前一次写入操作使用。 - - - 将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。 - 要写入流中的字节。 - 发生 I/O 错误。 - 该流不支持写入，或者该流已关闭。 - 在流关闭后调用方法。 - 2 - - - 获取或设置一个值（以毫秒为单位），该值确定流在超时前尝试写入多长时间。 - 一个确定流在超时前尝试写入多长时间的值（以毫秒为单位）。 - - 方法总是引发 。 - 2 - - - 实现一个 ，使其以一种特定的编码从字节流中读取字符。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 为指定的流初始化 类的新实例。 - 要读取的流。 - - 不支持读取。 - - 为 null。 - - - 用指定的字节顺序标记检测选项，为指定的流初始化 类的一个新实例。 - 要读取的流。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 为 null。 - - - 用指定的字符编码为指定的流初始化 类的一个新实例。 - 要读取的流。 - 要使用的字符编码。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码和字节顺序标记检测选项。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - - 不支持读取。 - - 或 为 null。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小。 - 要读取的流。 - 要使用的字符编码。 - 指示是否在文件头查找字节顺序标记。 - 最小缓冲区大小。 - 流不支持读取。 - - 或 为 null。 - - 小于或等于零。 - - - 为指定的流初始化 类的新实例，带有指定的字符编码、字节顺序标记检测选项和缓冲区大小，有选择性的打开流。 - 要读取的流。 - 要使用的字符编码。 - 如果要在文件开头查找字节顺序标记，则为 true；否则为 false。 - 最小缓冲区大小。 - 如果在释放 对象后保持流处于打开状态，则为 true；否则为 false。 - - - 返回基础流。 - 基础流。 - 2 - - - 获取当前 对象正在使用的当前字符编码。 - 当前读取器所使用的当前字符编码。第一次调用 的任何 方法后，该值可能会不同，因为直到第一次调用 方法时，才会进行编码的自动检测。 - 2 - - - 清除内部缓冲区。 - 2 - - - 关闭基础流，释放 使用的未托管资源，同时还可以根据需要释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 获取一个值，该值指示当前的流位置是否在流结尾。 - 如果当前流位置位于流的末尾，则为 true；否则为 false。 - 基础流已释放。 - 1 - - - 空流周围的 。 - 1 - - - 返回下一个可用字符，但不使用它。 - 为表示下一个要读取的字符的整数，或者，如果没有要读取的字符或该流不支持查找，则为 -1。 - 发生 I/O 错误。 - 1 - - - 读取输入流中的下一个字符并使该字符位置提升一个字符。 - 输入流中表示为 对象的下一个字符。如果不再有可用的字符，则为 -1。 - 发生 I/O 错误。 - 1 - - - 从指定的索引位置开始将来自当前流的指定的最多字符读到缓冲区。 - 已读取的字符数，或者如果已到达流结尾并且未读取任何数据，则为 0。该数小于或等于 参数，具体取决于流中是否有可用的数据。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 开始写入的 的索引。 - 要读取的最大字符数。 - 缓冲区长度减去 小于 。 - - 为 null。 - - 或 为负。 - 出现 I/O 错误，如流被关闭。 - 1 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入缓冲区之前已到达流结尾，则将返回当前方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取指定的最大字符数并从指定的索引位置开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，取决于是否所有的输入字符都已读取。 - 此方法返回时，包含指定的字符数组，该数组的 和 () 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生了 I/O 错误。 - - - 从当前流中异步读取指定的最大字符，并且从指定的索引位置开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可小于所请求的字节数；如果已到达流结尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定的字符数写入到缓冲区之前就已经达到流结尾，则将返回此方法。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前流中读取一行字符并将数据作为字符串返回。 - 输入流中的下一行；如果到达了输入流的末尾，则为 null。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 从当前流中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自流的下一行；如果读取了所有字符，则为 null。 - 下一行中的字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取来自流的当前位置到结尾的所有字符。 - 字符串形式的流的其余部分（从当前位置到结尾）。如果当前位置位于流结尾，则返回空字符串 (“”)。 - 内存不足，无法为返回的字符串分配缓冲区。 - 发生 I/O 错误。 - 1 - - - 异步读取来自流的当前位置到结尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括带有从流的当前位置到结尾的字符的字符串。 - 字符数大于 。 - 流已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个 ，使其以一种特定的编码向流中写入字符。若要浏览此类型的.NET Framework 源代码，请参阅参考源。 - 1 - - - 用 UTF-8 编码及默认缓冲区大小，为指定的流初始化 类的一个新实例。 - 要写入的流。 - - 不可写。 - - 为 null。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - - 或 为 null。 - - 不可写。 - - - 用指定的编码及缓冲区大小，为指定的流初始化 类的新实例。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 用指定的编码及默认缓冲区大小，为指定的流初始化 类的新实例，有选择性的打开流。 - 要写入的流。 - 要使用的字符编码。 - 缓冲区大小（以字节为单位）。 - true to leave the stream open after the object is disposed; otherwise, false. - - 或 为 null。 - - 为负数。 - - 不可写。 - - - 获取或设置一个值，该值指示 是否在每次调用 之后，将其缓冲区刷新到基础流。 - 强制 刷新其缓冲区时，为 true；否则，为 false。 - 1 - - - 获取同后备存储连接的基础流。 - 此 StreamWriter 正在写入的基础流。 - 2 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - 当前编码不支持显示半个 Unicode 代理项对。 - - - 获取将输出写入到其中的 。 - 在当前实例的构造函数中指定的 ；或者如果未指定编码，则为 。 - 2 - - - 清理当前写入器的所有缓冲区，并使所有缓冲数据写入基础流。 - 当前编写器已关闭。 - 出现 I/O 错误。 - 当前编码不支持显示半个 Unicode 代理项对。 - 1 - - - 异步清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。 - 表示异步刷新操作的任务。 - 流已被释放。 - - - 提供 StreamWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将字符写入流。 - 要写入流中的字符。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符数组写入流。 - 包含要写入的数据的字符数组。如果 为 null，则不写入任何内容。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符的子数组写入流。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 发生 I/O 错误。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 1 - - - 将字符串写入流。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - - 为 true 或 缓冲区已满，并且当前编写器已关闭。 - - 为 true 或 缓冲区已满，并且由于 位于基础固定大小流的结尾，缓冲区的内容无法写入该流。 - 发生 I/O 错误。 - 1 - - - 将字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 包含要写入的数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入流的字符串。如果 为 null，则不写入任何内容。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将行终止符异步写入该流。 - 表示异步写操作的任务。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符异步写入该流。 - 表示异步写操作的任务。 - 要写入流中的字符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符的子数组异步写入该流。 - 表示异步写操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据时缓冲区中的字符位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 将后跟行终止符的字符串异步写入该流。 - 表示异步写操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 流编写器已被释放。 - 流编写器正在由其前一次写入操作使用。 - - - 实现从字符串进行读取的 。 - 2 - - - 初始化从指定字符串进行读取的 类的新实例。 - 应将 初始化为的字符串。 - - 参数为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 返回下一个可用的字符，但不使用它。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该流不支持查找，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的下一个字符并将该字符的位置提升一个字符。 - 基础字符串中的下一个字符，或者如果没有更多的可用字符，则为 -1。 - 当前读取器已关闭。 - 2 - - - 读取输入字符串中的字符块，并将字符位置提升 。 - 读入缓冲区的总字符数。如果当前没有那么多字符可用，则总字符数可能会少于所请求的字符数，或者如果已到达基础字符串的结尾，则总字符数为零。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 缓存区中的起始索引。 - 要读取的字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - 当前读取器已关闭。 - 2 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 异步从当前字符串中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已到达字符串的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 最多读取的字符数。如果在写入指定数目的字符到缓冲区之前，就已经达到字符串的末尾，则方法返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前字符串中读取一行字符并将数据作为字符串返回。 - 当前字符串中的下一行；或为 null （如果到达了字符串的末尾）。 - 当前读取器已关闭。 - 内存不足，无法为返回的字符串分配缓冲区。 - 2 - - - 从当前字符串中异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自字符串读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 从当前位置到基础字符串的结尾之间的内容。 - 内存不足，无法为返回的字符串分配缓冲区。 - 当前读取器已关闭。 - 2 - - - 异步读取从当前位置到字符串的结尾的所有字符并将它们作为单个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束字符串字符。 - 字符数大于 。 - 字符串读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 实现一个用于将信息写入字符串的 。该信息存储在基础 中。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式控制初始化 类的新实例。 - 控制格式设置的 对象。 - - - 初始化写入指定 的 类的新实例。 - 要写入的 StringBuilder。 - - 为 null。 - - - 初始化写入指定 并具有指定格式提供程序的 类的新实例。 - 要写入的 StringBuilder。 - 控制格式设置的 对象。 - - 为 null。 - - - 释放由 占用的非托管资源，还可以另外再释放托管资源。 - true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。 - - - 获取将输出写入到其中的 。 - 用来写入输出的 Encoding。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - - - 返回基础 。 - 基础 StringBuilder。 - 2 - - - 返回包含迄今为止写入到当前 StringWriter 中的字符的字符串。 - 包含写入到当前 StringWriter 中的字符的字符串。 - 2 - - - 将字符写入该字符串。 - 要写入的字符。 - 编写器已关闭。 - 2 - - - 将字符的子数组写入该字符串。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - 或 为负。 - ( + )> 。Length. - 编写器已关闭。 - 2 - - - 将字符串写入当前流。 - 要写入的字符串。 - 编写器已关闭。 - 2 - - - 以异步方式将字符写入流。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将字符串写入当前流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 以异步方式将后跟行结束符的字符写入该字符串。 - 表示异步写入操作的任务。 - 要写入字符串中的字符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入该字符串。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始读取数据缓存中的位置。 - 要写入的最大字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 将一后跟行结束符的字符串异步写入当前字符串。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 字符串编写器已被释放。 - 字符串编写器正在由其前一次写操作使用。 - - - 表示可读取有序字符系列的读取器。 - 2 - - - 初始化 类的新实例。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - true to release both managed and unmanaged resources; false to release only unmanaged resources. - - - 提供一个无数据可供读取的 TextReader。 - 1 - - - 读取下一个字符，而不更改读取器状态或字符源。返回下一个可用字符，而实际上并不从读取器中读取此字符。 - 一个表示下一个要读取的字符的整数；如果没有更多可读取的字符或该读取器不支持查找，则为 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 读取文本读取器中的下一个字符并使该字符的位置前移一个字符。 - 文本读取器中的下一个字符，或为 -1（如果没有更多可用字符）。默认实现将返回 -1。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 从当前读取器中读取指定数目的字符并从指定索引开始将该数据写入缓冲区。 - 已读取的字符数。该数会小于或等于 ，具体取决于读取器中是否有可用的数据。如果调用此方法时没有留下更多的字符供读取，则此方法返回 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前就已达读取器的末尾，则返回该方法。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从当前文本读取器中读取指定的最大字符数并从指定索引处开始将该数据写入缓冲区。 - 已读取的字符数。该数字将小于或等于 ，具体取决于是否所有的输入字符都已读取。 - 此方法返回时，此参数包含指定的字符数组，该数组中从 到 ( + -1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。 - - 为 null。 - 缓冲区长度减去 小于 。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 2 - - - 异步从当前文本读取器中读取指定最大字符数并从指定索引开始将该数据写入缓冲区。 - 表示异步读取操作的任务。 参数的值包含读入缓冲区的总字节数。如果当前可用字节数少于所请求的字节数，则该结果值可能小于所请求的字节数，或者如果已达到文本的末尾时，则为 0（零）。 - 此方法返回时，包含指定的字符数组，该数组的 和 ( + - 1) 之间的值由从当前源中读取的字符替换。 - 在 中开始写入的位置。 - 要读取的最大字符数。如果在将指定数量的字符读入缓冲区之前已到达文本的末尾，则当前方法将返回。 - - 为 null。 - - 或 为负。 - - 与 的和大于缓冲区长度。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 从文本读取器中读取一行字符并将数据作为字符串返回。 - 读取器中的下一行，或为 null （如果已读取了所有字符）。 - 发生 I/O 错误。 - 内存不足，无法为返回的字符串分配缓冲区。 - - 是关闭的。 - 下一行中的字符数大于 - 1 - - - 异步读取一行字符并将数据作为字符串返回。 - 表示异步读取操作的任务。 参数的值包含来自文本读取器的下一行或为 null 如果读取所有字符。 - 下一行中的字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 一个包含从当前位置到文本读取器末尾的所有字符的字符串。 - 发生 I/O 错误。 - - 是关闭的。 - 内存不足，无法为返回的字符串分配缓冲区。 - 下一行中的字符数大于 - 1 - - - 异步读取从当前位置到文本读取器末尾的所有字符并将它们作为一个字符串返回。 - 表示异步读取操作的任务。 参数值包括字符串来自当前位置到结束文本读取器字符。 - 字符数大于 。 - 文本读取器已被释放。 - 编写器正在由其前一次读取操作使用。 - - - 表示可以编写一个有序字符系列的编写器。此类为抽象类。 - 2 - - - 初始化 类的新实例。 - - - 使用指定的格式提供程序初始化 类的新实例。 - 控制格式设置的 对象。 - - - 存储用于此 TextWriter 的换行符。 - - - 释放由 对象使用的所有资源。 - - - 释放由 占用的非托管资源，还可以释放托管资源。 - 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 - - - 当在派生类中重写时，返回用来写输出的该字符编码。 - 用来写入输出的字符编码。 - 1 - - - 清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 1 - - - 异步清理当前编写器的所有缓冲区，使所有缓冲数据写入基础设备。 - 表示异步刷新操作的任务。 - 文本编写器已被释放。 - 编写器正在由其前一次写操作使用。 - - - 获取控制格式设置的对象。 - 特定区域性的 对象，或者如果未指定任何其他区域性，则为当前区域性的格式设置。 - 2 - - - 获取或设置由当前 TextWriter 使用的行结束符字符串。 - 当前 TextWriter 的行结束符字符串。 - 2 - - - 提供 TextWriter，它不带任何可写入但无法从中读取的后备存储。 - 1 - - - 将 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符写入该文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符数组写入该文本字符串或流。 - 要写入文本流中的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将字符的子数组写入文本字符串或流。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符串写入到文本字符串或流。 - 要写入的字符串。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0） 或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - - 或 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 以异步形式将字符写入到下一个文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符数组写入到下一个字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果 为 null，则不写入任何内容。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将字符的子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 以异步形式将字符串写入到下一字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果 为 null，则不会将任何内容写入文本流。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将行结束符的字符串写入文本字符串或流。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的 Boolean 值的文本表示形式写入文本字符串或流。 - 要写入的 Boolean 值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符写入文本字符串或流。 - 要写入文本流中的字符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符数组写入文本字符串或流。 - 从其读取数据的字符数组。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符子数组写入文本字符串或流。 - 从其读取数据的字符数组。 - 在开始读取数据时 中的字符位置。 - 要写入的最大字符数。 - 缓冲区长度减去 小于 。 - - 参数为 null。 - - 或 为负。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后面带有行结束符的十进制值的文本表示形式写入文本字符串或流。 - 要写入的十进制值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 8 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节有符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节有符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 通过在对象上调用 ToString 方法将后跟行结束符的此对象的文本表示形式写入文本字符串或流。 - 要写入的对象。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 4 字节浮点值的文本表示形式写入文本字符串或流。 - 要写入的 4 字节浮点值。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的字符串写入文本字符串或流。 - 要写入的字符串。如果 为 null，则只写入行终止符。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为一)。 - 1 - - - 使用与 方法相同的语义将格式化字符串和新行写入文本字符串或流。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为二)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 要格式化和写入的第一个对象。 - 要格式化和写入的第二个对象。 - 要设置格式和写入的第三个对象。 - - 为 null。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0 （0）、或大于或等于要设置格式的对象数 (用于该方法重载，为三)。 - 1 - - - 使用与 相同的语义写出格式化的字符串和一个新行。 - 复合格式字符串（请参见“备注”）。 - 一个对象数组，其中包含零个或多个要设置格式和写入的对象。 - 字符串或对象作为 null 传入。 - - 是关闭的。 - 发生 I/O 错误。 - - 不是有效的复合格式字符串。- 或 - 格式项的索引小于 0（零）或大于等于 数组的长度。 - 1 - - - 将后跟行结束符的 4 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 4 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将后跟行结束符的 8 字节无符号整数的文本表示形式写入文本字符串或流。 - 要写入的 8 字节无符号整数。 - - 是关闭的。 - 发生 I/O 错误。 - 1 - - - 将行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入文本流中的字符数组。如果字符数组为 null，则仅写入行结束符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符子数组异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要从中写出数据的字符数组。 - 在开始接收数据时缓存中的字符位置。 - 要写入的字符数。 - - 为 null。 - - plus 大于缓冲区长度。 - - 或 为负。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - 将后跟行结束符的字符串异步写入文本字符串或流。 - 表示异步写入操作的任务。 - 要写入的字符串。如果值为 null，则只写入行终止符。 - 文本编写器已被释放。 - 文本编写器正在由其前一次写操作使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml b/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml deleted file mode 100644 index 26192a9d..00000000 --- a/packages/System.IO.4.1.0/ref/netstandard1.5/zh-hant/System.IO.xml +++ /dev/null @@ -1,2246 +0,0 @@ - - - - System.IO - - - - 以特定的編碼方式，將基本資料型別當做二進位值讀取。 - 2 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸入資料流。 - 資料流不支援讀取，為 null，或已經關閉。 - - - 根據指定的資料流和字元編碼，初始化 類別的新執行個體。 - 輸入資料流。 - 要使用的字元編碼。 - 資料流不支援讀取，為 null，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和特定的字元編碼，初始化 類別的新執行個體，並選擇性地保留資料流開啟狀態。 - 輸入資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - 資料流不支援讀取，為 null，或已經關閉。 - - 或 為 null。 - - - 公開 之基礎資料流的存取。 - 與 BinaryReader 相關聯的基礎資料流。 - 2 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 將從資料流讀取的指定位元組數目填入內部緩衝區。 - 要讀取的位元組數。 - 在 可讀取之前到達資料流末端。 - 發生 I/O 錯誤。 - 所要求的 大於內部緩衝區大小。 - - - 傳回下一個可用字元，而不前移位元組或字元的位置。 - 下一個可用的字元；如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 無法使用針對資料流選取的 將目前的字元解碼到內部字元緩衝區。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自基礎資料流讀取字元，並將資料流中目前的位置往前移。 - 輸入資料流的下一個字元；如果目前沒有字元可供使用，則為 -1。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 由位元組陣列中指定點開始，讀取資料流中的指定位元組數。 - 要讀入 的位元組數。如果沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的位元組數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 由字元陣列中的指定點開始，從資料流讀取指定字元數。 - 讀入緩衝區的字元總數。如果目前沒有足夠的位元組數，這可能會小於要求的位元組數；如果已到達資料流末端，則可能為零。 - 要讀取資料的緩衝區。 - 開始讀取資料到緩衝區的緩衝區起始點。 - 要讀取的字元數。 - 緩衝區長度減去 小於 。-或-欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - - 為 null。 - - 或 為負值。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以壓縮格式讀取 32 位元整數。 - 壓縮格式的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 資料流已損毀。 - - - 自目前資料流讀取 Boolean 值，並將資料流中目前的位置往前移一個位元組。 - 如果位元組為非零值，則為 true；否則為 false。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取下一個位元組，並將資料流中目前的位置往前移一個位元組。 - 自目前資料流讀取的下一個位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 將目前資料流中的指定位元組數讀入位元組陣列中，並將目前的位置前移該位元組數。 - 位元組陣列，含有自基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的位元組數。 - 要讀取的位元組數。這個值必須是 0 或非負數，否則會發生例外狀況。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為負值。 - 2 - - - 按照所使用的 Encoding 和從資料流讀取的特定字元，自目前資料流讀取下一個字元，並將資料流中目前的位置往前移。 - 自目前資料流讀取的字元。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 讀取到 Surrogate 字元 - 2 - - - 讀取目前資料流中的指定字元數，並將資料傳入字元陣列中，然後依據使用的 Encoding 以及正在從資料流中讀取的指定字元，前移目前的位置。 - 字元陣列，含有從基礎資料流讀取的資料。如果已到達資料流末端，這可能會小於要求的字元數。 - 要讀取的字元數。 - 欲讀取的解碼字元數大於 。如果 Unicode 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。 - 已關閉資料流。 - 發生 I/O 錯誤。 - - 為負值。 - 2 - - - 自目前資料流讀取十進位值，並將資料流的目前位置前移十六個位元組。 - 自目前資料流讀取的十進位值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組浮點數值，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 2 位元組帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自目前資料流讀取的 2 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自目前資料流讀取的 8 位元組帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自資料流讀取帶正負號的位元組，並將資料流目前位置前移一個位元組。 - 自資料流讀取的帶正負號的位元組。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組浮點數值，並將資料流目前位置前移四個位元組。 - 自目前資料流讀取的 4 位元組浮點數值。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取字串。字串會以長度為前置字元，每次以七位元編碼為一整數。 - 讀取的字串。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 以位元組由小到大的編碼方式自目前資料流讀取 2 位元組不帶正負號的整數，並將資料流目前位置前移兩個位元組。 - 自這個資料流讀取 2 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 4 位元組不帶正負號的整數，並將資料流目前位置前移四個位元組。 - 自這個資料流讀取 4 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 2 - - - 自目前資料流讀取 8 位元組不帶正負號的整數，並將資料流目前位置前移八個位元組。 - 自這個資料流讀取 8 位元組不帶正負號的整數。 - 已到達資料流的末端。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 2 - - - 以二進位方式將基本型別 (Primitive Type) 寫入資料流，並支援以特定編碼方式寫入字串。 - 2 - - - 初始化 類別的新執行個體，其將寫入資料流。 - - - 根據指定的資料流並使用 UTF-8 編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 資料流不支援寫入，或已經關閉。 - - 為 null。 - - - 根據指定的資料流和字元編碼方式，初始化 類別的新執行個體。 - 輸出資料流。 - 要使用的字元編碼。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 根據指定的資料流和特定的字元編碼方式，初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 輸出資料流。 - 要使用的字元編碼。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - 資料流不支援寫入，或已經關閉。 - - 或 是 null。 - - - 取得 的基礎資料流。 - 與 BinaryWriter 相關聯的基礎資料流。 - 1 - - - 將 類別目前的執行個體所使用的資源全部釋出。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 指定沒有備份存放區的 。 - 1 - - - 容納基礎資料流。 - - - 設定目前資料流位置。 - 目前資料流的位置。 - 相對於 的位元組位移。 - - 的欄位，表示要取得新位置的參考點。 - 檔案指標已移至無效的位置。 - - 值是無效的。 - 1 - - - 寫入一位元組的 Boolean 值至目前資料流，其中 0 表示 false，1 表示 true。 - 要寫入的 Boolean 值 (0 或 1)。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將不帶正負號 (Unsigned) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的不帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將位元組陣列寫入基礎資料流。 - 含有要寫入之資料的位元組陣列。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 為 null。 - 1 - - - 將一個區域的位元組陣列寫入目前資料流。 - 含有要寫入之資料的位元組陣列。 - - 中要開始寫入的起始點。 - 要寫入的位元組數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將 Unicode 字元寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 非 Surrogate，要寫入的 Unicode 字元。 - 發生 I/O 錯誤。 - 已關閉資料流。 - - 是單一 Surrogate 字元。 - 1 - - - 將字元陣列寫入至目前資料流，並按照所使用的 Encoding 和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 為 null。 - 已關閉資料流。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列中的一區段寫入至目前的資料流，並按照所使用的 Encoding 和可能為寫入資料流的特定字元，將資料流中目前的位置往前移。 - 含有要寫入之資料的字元陣列。 - - 中要開始寫入的起始點。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將十進位值寫入目前的資料流，並將資料流位置往前移十六個位元組。 - 要寫入的十進位值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組浮點數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將二位元組帶正負號的整數 (Signed Integer) 寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組帶正負號的整數寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將帶正負號 (Signed) 位元組寫入目前資料流，並將資料流位置前移一個位元組。 - 要寫入的帶正負號位元組。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組浮點數 (Floating-Point) 值寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組浮點數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將有長度前置字元的字串以目前 的編碼方式寫入此資料流，並按照所使用的編碼方式和寫入資料流的特定字元，將資料流中目前的位置往前移。 - 要寫入的值。 - 發生 I/O 錯誤。 - - 為 null。 - 已關閉資料流。 - 1 - - - 將二位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移兩個位元組。 - 要寫入的二位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將四位元組不帶正負號的整數寫入目前資料流，並將資料流目前位置前移四個位元組。 - 要寫入的四位元組不帶正負號的整數。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 將八位元組不帶正負號的整數值寫入目前資料流，並將資料流目前位置前移八個位元組。 - 要寫入的八位元組不帶正負號的整數值。 - 發生 I/O 錯誤。 - 已關閉資料流。 - 1 - - - 以壓縮格式寫入 32 位元整數。 - 要寫入的 32 位元整數。 - 已到達資料流的末端。 - 已關閉資料流。 - 已關閉資料流。 - - - 嘗試超過資料流末端進行讀取時所擲回的例外狀況。 - 2 - - - 將其訊息字串設定為系統提供的訊息且將其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - - - 使用其訊息字串設定為 和其 HRESULT 設定為 COR_E_ENDOFSTREAM，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - - - 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 描述錯誤的字串。 的內容必須能讓人了解。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 資料流在格式無效時擲回的例外狀況。 - - - 初始化 類別的新執行個體。 - - - 使用指定的錯誤訊息，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - - - 使用造成這個例外狀況原因的內部例外參考，初始化 類別的新執行個體。 - 解釋例外狀況原因的錯誤訊息。 - 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 - - - 建立支援的存放區為記憶體的資料流。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 使用初始化為零的可擴展容量，初始化 類別的新執行個體。 - - - 根據指定的位元組陣列，初始化 類別之不可調整大小的執行個體。 - 用於建立目前資料流之不帶正負號位元組的陣列。 - - 為 null。 - - - 根據具有指定的 屬性設定之位元組陣列，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - - 根據位元組陣列的指定區域 (索引)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 為 null。 - - 或 小於零。 - 緩衝區長度減去 小於 。 - - - 根據位元組陣列的指定區域 (且該區域使用依指定所設定的 屬性)，來初始化 類別之新的不可調整大小的執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 根據指定的位元組陣列區域 (且該區域使用依指定所設定的 屬性和依指定所設定的呼叫 的能力)，來初始化 類別的新執行個體。 - 用於建立這個資料流之不帶正負號位元組的陣列。 - - 中資料流開始處的索引。 - 資料流的長度，以位元組為單位。 - - 屬性的設定，決定資料流是否支援寫入。 - 啟用 (傳回從其中建立資料流的不帶正負號的位元組陣列)，則為 true；否則為 false。 - - 為 null。 - - 或 為負值。 - 緩衝區長度減去 小於 。 - - - 使用初始化為指定的可擴展容量，初始化 類別的新執行個體。 - 內部陣列的初始大小，以位元組為單位。 - - 為負值。 - - - 取得表示目前資料流是否支援讀取的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援搜尋的值。 - true，如果資料流已開啟。 - 2 - - - 取得表示目前資料流是否支援寫入的值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 2 - - - 取得或設定配置給這個資料流的位元組數目。 - 資料流緩衝區可使用部分的長度。 - 設定的容量為負數或小於資料流目前的長度。 - 目前的資料流已經關閉。 - set 在無法修改其容量的資料流上被叫用 (Invoke)。 - 2 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。 - 用來監視是否有取消要求的語彙基元。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 類別所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 覆寫 方法，以便不執行任何動作。 - 2 - - - 非同步清除這個資料流的所有緩衝區，並監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。 - 已處置資料流。 - - - 取得資料流的長度，以位元組為單位。 - 資料流的長度，以位元組為單位。 - 已關閉資料流。 - 2 - - - 取得或設定資料流中目前的位置。 - 在資料流的目前位置。 - 位置設為負數值或大於 的值。 - 已關閉資料流。 - 2 - - - 從目前的資料流讀取位元組區塊，並且將資料寫入緩衝區。 - 寫入至緩衝區的總位元組數。如果目前無法提供那麼多的位元組數目，則這個數目可能小於所要求的位元組數目，或如果在讀取任何資料之前已經到達資料流末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定位元組陣列，該值是由讀取自目前資料流的字元所取代。 - - 中以零為起始的位元組位移，用來開始儲存讀取自目前資料流的資料。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - 緩衝區的長度減去 小於 。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從目前的資料流讀取位元組。 - 轉型為 的位元組；如果已經到達資料流的末端，則為 -1。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流中的位置設定為指定的數值。 - 資料流中的新位置，是組合初始的參考點和位移計算出來的。 - 資料流中的新位置。這是相對於 參數，並且可能是正數或負數。 - - 類型的值，做為搜尋參考點。 - 在資料流開頭之前嘗試搜尋。 - - 大於 。 - 有無效的 。-或- 造成了算術溢位。 - 目前的資料流執行個體已關閉。 - 2 - - - 將目前資料流的長度設定為指定的數值。 - 要設定長度的數值。 - 目前的資料流不是可調整大小的，並且 大於目前的容量。-或- 目前的資料流不支援寫入。 - - 為負，或大於 的最大長度，最大長度是 ( - 原點)，原點是資料流開始的基礎緩衝區索引。 - 2 - - - 不論 屬性為何，將資料流內容寫入位元組陣列。 - 新的位元組陣列。 - 2 - - - 傳回用於建立這個資料流之不帶正負號位元組的陣列。指出轉換是否成功的傳回值。 - 如果轉換成功，則為 true；否則為 false。 - 從其中建立此資料流的位元組陣列區段。 - - - 使用讀取自緩衝區的資料，將位元組區塊寫入至目前的資料流。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入的最大位元組數。 - - 為 null。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 和 位元組相比，目前的位置更接近資料流末端，並且容量無法修改。 - 緩衝區的長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - 目前的資料流執行個體已關閉。 - 2 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入位元組至資料流目前位置。 - 要寫入的位元組。 - 資料流不支援寫入。如需詳細資訊，請參閱 。-或- 目前的位置在資料流結尾，並且無法修改容量。 - 目前的資料流已經關閉。 - 2 - - - 將這個記憶體資料流的整個內容寫入另一個資料流。 - 要寫入這個記憶體資料流的資料流。 - - 為 null。 - 目前的資料流或目標資料流已經關閉。 - 2 - - - 指定資料流中要用於搜尋的位置。 - 2 - - - 指定資料流的開端。 - - - 指定資料流中的目前位置。 - - - 指定資料流的末端。 - - - 提供位元組順序的一般觀點。這是 abstract 類別。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 2 - - - 初始化 類別的新執行個體。 - - - 在衍生類別中覆寫時，取得指示目前的資料流是否支援讀取的數值。 - 如果資料流支援讀取，則為 true；否則為 false。 - 1 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援搜尋的數值。 - 如果資料流支援搜尋，則為 true；否則為 false。 - 1 - - - 取得值，該值判斷目前的資料流是否可以逾時。 - 值，判斷目前的資料流是否可以逾時。 - 2 - - - 在衍生類別中覆寫時，取得指示目前資料流是否支援寫入的數值。 - 如果資料流支援寫入，則為 true；否則，為 false。 - 1 - - - 從目前資料流讀取位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 使用指定的緩衝區大小，從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流不支援讀取。-或- 不支援寫入。 - 目前資料流或 已經在呼叫 方法之前關閉。 - 發生 I/O 錯誤。 - - - 以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - - 為 null。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小，以非同步的方式從目前資料流讀取所有位元組，並將其寫入另一個資料流中。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 使用指定的緩衝區大小和取消語彙基元，以非同步的方式從目前資料流讀取位元組，並將其寫入另一個資料流。 - 表示非同步複製作業的工作。 - 目前資料流的內容將複製到其中的資料流。 - 緩衝區的大小 (以位元組為單位)。這個值必須大於零。預設大小為 81920。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 為負值或零。 - 目前資料流或目的資料流已處置。 - 目前資料流不支援讀取，或目的資料流不支援寫入。 - - - 釋放 所使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫時，會清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 發生 I/O 錯誤。 - 2 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 已處置資料流。 - - - 以非同步的方式清除這個資料流的所有緩衝區，造成任何緩衝資料都寫入基礎裝置，並且監視取消要求。 - 表示非同步排清作業的工作。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - 已處置資料流。 - - - 在衍生類別中覆寫時，取得資料流的長度 (以位元組為單位)。 - 代表資料流長度的長數值 (以位元組為單位)。 - 衍生自 Stream 的類別不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 沒有底層存放區的 Stream。 - 1 - - - 在衍生類別中覆寫時，取得或設定在目前資料流的位置。 - 在資料流的目前位置。 - 發生 I/O 錯誤。 - 資料流不支援搜尋。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 當在衍生類別中覆寫時，自目前資料流讀取一連串的位元組，並依所讀取的位元組數目進階資料流中的位置。 - 緩衝區所讀取的總位元組數。如果目前無法取得足夠的位元組，則這個數目可能小於所要求的位元組數，如果已經到達資料流末端，則為零 (0)。 - 位元組陣列。當這個方法返回時，緩衝區會包含具有介於 和 ( + - 1) 值的指定位元組陣列，由從目前來源讀取的位元組所取代。 - - 中以零起始的位元組位移，即開始儲存讀取自目前資料流之資料的位置。 - 自目前資料流讀取的最大位元組數。 - - 和 的總和大於緩衝區的長度。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 以非同步的方式從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 以非同步的方式從目前資料流讀取一連串的位元組、依所讀取的位元組數目進階資料流中的位置，以及監視取消要求。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 寫入資料的緩衝區。 - 開始於此處自資料流寫入資料的 中的位元組位移。 - 要讀取的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援讀取。 - 已處置資料流。 - 資料流目前由先前讀取作業所使用。 - - - 從資料流讀取一個位元組，並將資料流的位置推進一個位元組；如果在資料流末端，則傳回 -1。 - 轉型為 Int32 的不帶正負號位元組，如果在資料流末端，則為 -1。 - 資料流不支援讀取。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試讀取多長時間。 - - 方法必須擲回 。 - 2 - - - 在衍生類別中覆寫時，設定在目前資料流的位置。 - 目前資料流的新位置。 - 相對於 參數的位元組位移。 - - 類型的值，表示用來取得新位置的參考點。 - 發生 I/O 錯誤。 - 資料流不支援搜尋，例如資料流為管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 1 - - - 在衍生類別中覆寫時，設定目前資料流的長度。 - 想要的目前資料流長度 (單位為位元組)。 - 發生 I/O 錯誤。 - 資料流不支援寫入和搜尋，例如，如果資料流是從管道或主控台 (Console) 輸出所建構。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 在衍生類別中覆寫時，將一連串的位元組寫入目前的資料流，並且由這個資料流中目前的位置前移寫入的位元組數目。 - 位元組陣列。此方法會從 複製 位元組到目前資料流。 - - 中以零起始的位元組位移，即開始將位元組複製到目前資料流的位置。 - 寫入目前資料流的位元組數目。 - 总和  和  大于缓冲区长度。 - - 是 null。 - - 或  为负。 - 将出现 I/O 错误，如找不到指定的文件。 - 資料流不支援寫入。 - - 流关闭后调用。 - 1 - - - 以非同步的方式將位元組序列寫入至目前的資料流，並依寫入的位元組數將資料流中目前的位置往前移。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 以非同步的方式將一連串的位元組寫入目前的資料流，由這個資料流中目前的位置前移寫入的位元組數目，並且監視取消要求。 - 表示非同步寫入作業的工作。 - 寫入資料的來源緩衝區。 - - 中以零起始的位元組位移，要從其中開始將位元組複製至資料流。 - 寫入的最大位元組數。 - 用來監視是否有取消要求的語彙基元。預設值是 。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 資料流不支援寫入。 - 已處置資料流。 - 資料流目前由先前寫入作業所使用。 - - - 寫入一個位元組至資料流的目前位置，並將資料流位置推進一個位元組。 - 寫入資料流的位元組。 - 發生 I/O 錯誤。 - 資料流不支援寫入，或資料流已經關閉。 - 在資料流關閉後，會呼叫方法。 - 2 - - - 取得或設定值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - 值 (以毫秒為單位)，該值決定在逾時前資料流將嘗試寫入多長時間。 - - 方法必須擲回 。 - 2 - - - 實作以特定的編碼方式自位元組資料流讀取字元的 。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 - 1 - - - 為指定的資料流，初始化 類別的新執行個體。 - 要讀取的資料流。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的位元組順序標記偵測選項，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 為 null。 - - - 使用指定的字元編碼，針對指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼和位元組順序標記偵測選項，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - - 不支援讀取。 - - 或 為 null。 - - - 使用指定的字元編碼、位元組順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要讀取的資料流。 - 要使用的字元編碼。 - 表示是否在檔案開頭尋找位元組順序標記。 - 最小緩衝區大小。 - 資料流不支援讀取。 - - 或 為 null。 - - 小於或等於零值。 - - - 根據指定的字元編碼、位元順序標記偵測選項和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要讀取的資料流。 - 要使用的字元編碼。 - true 表示在檔案開頭尋找位元順序標記；否則為 false。 - 最小緩衝區大小。 - true 表示在處置 物件之後，將資料流保持開啟；否則為 false。 - - - 傳回基礎資料流。 - 基礎資料流。 - 2 - - - 取得目前 物件使用的目前字元編碼。 - 目前讀取器所使用的字元編碼。在第一次呼叫 的任何 方法之後其值可能不同，因為編碼方式的自動偵測要等到第一次呼叫 方法後才完成。 - 2 - - - 清除內部緩衝區。 - 2 - - - 關閉基礎資料流，接著釋放 所使用的 Unmanaged 資源，然後再選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得表示現行資料流位置是否在資料流結尾的值。 - 如果現行資料流位置在資料流的結尾，則為 true；否則為 false。 - 已處置基礎資料流。 - 1 - - - 空資料流周圍的 物件。 - 1 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有要讀取的字元或資料流不支援搜尋，則為 -1。 - 發生 I/O 錯誤。 - 1 - - - 自輸入資料流讀取下一個字元，並將字元位置前移一個字元。 - 來自輸入資料流的下一個字元會以 物件來表示；如果不再有可以使用的字元，則以 -1 表示。 - 發生 I/O 錯誤。 - 1 - - - 從目前資料流讀取指定的字元數目上限，在指定的索引位置開始讀入緩衝區中。 - 已讀取字元數，或為 0 (如果處於資料流末端而無資料讀取)。數目將小於或等於 參數，取決於資料流內是否有資料可供使用。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - 要開始寫入的 的索引。 - 要讀取的字元數上限。 - 緩衝區長度減去 小於 。 - - 為 null。 - - 或 為負值。 - 發生 I/O 錯誤，例如資料流已經關閉。 - 1 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前資料流讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，會包含具有介於 和 () 的值之指定字元陣列，這個值是由從目前來源讀取的字元所取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - - - 從目前的資料流非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。 參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達資料流末端，則可能為 0 (零)。 - 當這個方法傳回時，會包含指定的字元陣列，而該字元陣列中具有介於 和 ( + - 1) 之間的值，會由從目前來源讀取而來的字元取代。 - - 中要開始寫入的位置。 - 要讀取的字元數上限。如果指定的字元數寫入緩衝區之前，便到達資料流末端，則方法會返回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前資料流讀取一行字元，並將資料以字串傳回。 - 輸入資料流的下一行，或為 null (如果已到達輸入資料流末端)。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 自目前資料流非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含資料流中的下一行，或者是 null (如果已經讀取所有字元)。 - 下一行中的字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到資料流末端的所有字元。 - 資料流從目前位置到末端的其餘字串。如果目前位置位於資料流末端，則傳回空字串 ("")。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 發生 I/O 錯誤。 - 1 - - - 非同步讀取從目前位置到資料流末端的所有字元，並將它們以字串傳回。 - 表示非同步讀取作業的工作。 參數的值會包含字串，該字串含有從目前位置到資料流結尾的字元。 - 字元數大於 。 - 已處置資料流。 - 讀取器目前由先前讀取作業所使用。 - - - 實作以特定的編碼方式將字元寫入位元組資料流的 。若要瀏覽此類型的.NET Framework 原始碼，請參閱參考來源。 - 1 - - - 使用 UTF-8 編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - - 不可寫入。 - - 為 null。 - - - 使用指定的編碼方式和預設緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - - 或 是 null。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 使用指定的編碼方式和緩衝區大小，為指定的資料流初始化 類別的新執行個體，並選擇性讓資料流保持開啟。 - 要寫入的資料流。 - 要使用的字元編碼。 - 緩衝區大小，以位元組為單位。 - true 表示在處置 物件之後，將資料流保持開啟，否則為 false。 - - 或 是 null。 - - 為負值。 - - 不可寫入。 - - - 取得或設定值，指出 在每次呼叫 之後，是否要將其緩衝區清除到基礎資料流。 - 強制 清除其緩衝區，則為 true，否則為 false。 - 1 - - - 取得以備份存放區作介面的基礎資料流。 - StreamWriter 正在寫入的資料流。 - 2 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - - - 取得寫入輸出的 。 - - (在目前執行個體的建構函式中指定)；如果未指定編碼方式，則為 。 - 2 - - - 清除目前寫入器 (Writer) 的所有緩衝區，並且造成所有緩衝資料都寫入基礎資料流。 - 目前寫入器已關閉。 - 發生 I/O 錯誤。 - 目前的編碼不支援顯示 Unicode Surrogate 字組的其中一半。 - 1 - - - 以非同步的方式清除這個資料流的所有緩衝區，並造成所有緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - 已處置資料流。 - - - 提供 StreamWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將一個字元寫入資料流。 - 要寫入資料流的字元。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元陣列寫入資料流。 - 含有要寫入之資料的字元陣列。如果 是 null，則不寫入任何資料。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字元子陣列寫入資料流。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - 發生 I/O 錯誤。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 1 - - - 將字串寫入資料流。 - 要寫入資料流的字串。如果 是 Null，則不會寫入任何資料。 - - 為 True，或 緩衝區已滿，且目前的寫入器已經關閉。 - - 為 True，或 緩衝區已滿，且因為 是在資料流緩衝區的結尾，所以該緩衝區的內容無法寫入至基礎的固定大小資料流。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入資料流。 - 表示非同步寫入作業的工作。 - 含有要寫入之資料的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字串。如果 是 null，則不寫入任何資料。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 將行結束字元以非同步方式寫入資料流。 - 表示非同步寫入作業的工作。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入資料流的字元。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的字元位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 資料流寫入器已處置。 - 資料流寫入器目前由先前寫入作業所使用。 - - - 實作讀取字串的 。 - 2 - - - 初始化 類別的新執行個體，這個執行個體會從指定的字串讀取。 - - 應該初始化的目的字串。 - - 參數為 null。 - - - 釋放 使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 傳回下一個可供使用的字元，但不使用它。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或資料流不支援搜尋，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取下一個字元，並將字元位置前移一個字元。 - 基礎字串的下一個字元；如果不再有字元可供使用，則為 -1。 - 目前的讀取器已關閉。 - 2 - - - 自輸入字串讀取字元區塊，並將字元位置前移 個字元。 - 讀入緩衝區的字元總數。如果目前無法提供那麼多的字元數，則這個數目可能小於所要求的字元數，或如果已經到達基礎字串的末端，則為零。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - 緩衝區中的起始索引。 - 要讀取的字元數。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負數。 - 目前的讀取器已關閉。 - 2 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的字串非同步讀取指定的取大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達字串末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的最大字元數。如果指定的字元數寫入緩衝區之前，便到達字串末端，則方法會返回。 - - 為 null。 - - 或 為負數。 - - 和 的總和大於緩衝區的長度。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自目前字串讀取一行字元，並將資料以字串傳回。 - 目前字串的下一行，如果已到達字串的結尾，則為 null。 - 目前的讀取器已關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 2 - - - 自目前字串非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 基礎字串從目前位置至結尾的內容。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 目前的讀取器已關閉。 - 2 - - - 非同步讀取從目前位置到字串末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到字串結尾的字元。 - 字元數大於 。 - 字串讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 實作 以便將資訊寫入字串。資訊儲存在基礎 中。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的控制項格式，初始化 類別的新執行個體。 - 控制格式的 物件。 - - - 初始化 類別的新執行個體，這個執行個體可寫入至指定的 。 - 要寫入至其中的 StringBuilder。 - - 為 null。 - - - 初始化 類別的新執行個體，這個執行個體會寫入至指定的 ，並且具有指定的格式提供者。 - 要寫入至其中的 StringBuilder。 - 控制格式的 物件。 - - 為 null。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示會同時釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 取得寫入輸出的 。 - 寫入輸出的 Encoding。 - 1 - - - 以非同步的方式清除目前寫入器 (Writer) 的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步清除作業的工作。 - - - 傳回基礎 。 - 基礎 StringBuilder。 - 2 - - - 傳回字串，包含被寫入至目前 StringWriter 的字元。 - 字串，包含被寫入至目前 StringWriter 的字元。 - 2 - - - 將一個字元寫入至字串。 - 要寫入的字元。 - 寫入器關閉。 - 2 - - - 將字元子陣列寫入至字串。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 或 為負數。 - ( + )> 。Length. - 寫入器關閉。 - 2 - - - 將字串寫入至目前字串。 - 要寫入的字串。 - 寫入器關閉。 - 2 - - - 以非同步方式將字元寫入至字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入至字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入至目前字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串至文字資料流。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 要寫入至字串的字元。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到字串。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始讀取資料的位置。 - 要寫入的最大字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負數。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (後面接著行結束字元) 寫入至目前的字串。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元 (Terminator)。 - 字串寫入器已處置。 - 字串寫入器目前由先前寫入作業所使用。 - - - 代表可以讀取一連串連續字元的讀取器 (Reader)。 - 2 - - - 初始化 類別的新執行個體。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 提供未讀取資料的 TextReader。 - 1 - - - 讀取下一個字元，而不會變更讀取器或字元來源的狀態。傳回下一個可用字元，而不會實際從讀取器讀取。 - 整數，表示要讀取的下一個字元，如果沒有更多字元可供使用或讀取器不支援搜尋，則為 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 自文字讀取器讀取下一個字元，並將字元位置前移一個字元。 - 文字讀取器的下一個字元；如果不再有字元可供使用，則為 -1。預設的實作會傳回 -1。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於資料是否在讀取器裡可供使用。如果不再有字元可供讀取時呼叫，這個方法傳回 0 (零)。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達讀取器末端，則方法會返回。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 從目前的文字讀取器讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 已經讀取的字元數目。數目將小於或等於 ，取決於是否已經讀取所有輸入字元。 - 當這個方法返回時，這個參數會包含具有介於 和 ( + -1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。 - - 為 null。 - 緩衝區長度減去 小於 。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 2 - - - 從目前的文字讀取器非同步讀取指定的最大字元數目，並從指定的索引開始將資料寫入緩衝區。 - 表示非同步讀取作業的工作。參數的值會包含讀取至緩衝區的位元組總數。如果目前可供使用的位元組數目少於所要求的數目，結果值可能會小於所要求的位元組數目，或者如果已經到達文字末端，則可能為 0（零）。 - 當這個方法返回時，會包含具有介於 和 ( + - 1) 之值的指定字元陣列，該值是由讀取自目前來源的字元所取代。 - - 中要開始寫入處的位置。 - 要讀取的字元數上限。如果指定的字元數讀入緩衝區之前，便到達文字末端，則目前的方法會傳回。 - - 為 null。 - - 或 為負值。 - - 和 的總和大於緩衝區的長度。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 自文字讀取器讀取一行字元，並將資料以字串傳回。 - 讀取器的下一行，或者如果所有字元都被讀取，則為 null。 - 發生 I/O 錯誤。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - - 已經關閉。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取一行字元，並將資料以字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含文字讀取器中的下一行，或者是null（如果已經讀取所有字元）。 - 下一行中的字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 字串，包含從目前位置到文字讀取器結尾的所有字元。 - 發生 I/O 錯誤。 - - 已經關閉。 - 沒有足夠的記憶體來為傳回的字串配置緩衝區。 - 下一行中的字元數大於 。 - 1 - - - 非同步讀取從目前位置到文字讀取器末端的所有字元，並將它們以單一字串傳回。 - 表示非同步讀取作業的工作。參數的值會包含字串，該字串含有從目前位置到文字讀取器結尾的字元。 - 字元數大於 。 - 文字讀取器已處置。 - 讀取器目前由先前讀取作業所使用。 - - - 代表可以寫入一連串連續字元的寫入器。這個類別是抽象的。 - 2 - - - 初始化 類別的新執行個體。 - - - 使用指定的格式提供者，初始化 類別的新執行個體。 - 控制格式設定的 物件。 - - - 儲存這個 TextWriter 所使用的新行字元。 - - - 釋放由 物件使用的所有資源。 - - - 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 - true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 - - - 當在衍生類別中覆寫該屬性時，傳回用於寫入輸出的字元編碼。 - 寫入輸出時使用的字元編碼。 - 1 - - - 清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 1 - - - 以非同步的方式清除目前寫入器的所有緩衝區，並造成任何緩衝資料都寫入基礎裝置。 - 表示非同步排清作業的工作。 - 文字寫入器已處置。 - 寫入器目前由先前寫入作業所使用。 - - - 取得控制格式設定的物件。 - 特定文化特性的 物件，或者目前文化特性的格式 (如果未指定其他文化特性)。 - 2 - - - 取得或設定目前 TextWriter 所使用的行結束字元字串。 - 目前 TextWriter 的行結束字元字串。 - 2 - - - 提供 TextWriter，但不包含可寫入但無法讀取的備份存放區。 - 1 - - - 將 Boolean 值的文字表示寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元陣列寫入到文字字串或資料流。 - 要寫入到文字資料流的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元的子陣列寫入到文字字串或資料流。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 呼叫該物件的 ToString 方法，將物件的文字表示寫入至文字字串或資料流。 - 要寫入的物件。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串寫入到文字字串或資料流。 - 要寫入的字串。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零) 或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - - 或 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果 是 null，則不寫入任何資料。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元的子陣列寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果 為 null，不寫入任何字串到文字資料流。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 將行結束字元寫入到文字字串或資料流。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 Boolean 值的文字表示，並加上行結束字元寫入到文字字串或資料流。 - 要寫入的 Boolean 值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入到文字資料流的字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 資料讀取來源的字元陣列。 - - 中開始讀取資料的字元位置。 - 要寫入的最大字元數。 - 緩衝區長度減去 小於 。 - - 參數為 null。 - - 或 為負值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將十進位值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的十進位值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 8 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 透過呼叫該物件上的 ToString 方法，將該物件的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的物件。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 4 位元組浮點數值的文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入的 4 位元組浮點數值。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 要寫入的字串。如果 為 null，只寫入行結束字元。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 要格式化及寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是一個)。 - 1 - - - 使用與 方法相同的語意，將格式化字串和新行寫入到文字字串或資料流。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是兩個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 第一個要格式化和寫入的物件。 - 第二個要格式化和寫入的物件。 - 第三個要格式化和寫入的物件。 - - 為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或大於或等於要格式化的物件數目 (就這個方法多載而言，是三個)。 - 1 - - - 使用與 相同的語意，寫出格式化字串和新行。 - 複合格式字串 (請參閱＜備註＞)。 - 物件陣列，包含零或多個要格式化和寫入的物件。 - 傳入的字串或物件為 null。 - - 已經關閉。 - 發生 I/O 錯誤。 - - 不是有效的複合格式字串。-或- 格式項目的索引小於 0 (零)，或者大於或等於 陣列的長度。 - 1 - - - 將 4 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 4 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 將 8 位元組不帶正負號的整數之文字表示加上行結束字元，寫入到文字字串或資料流。 - 要寫入之 8 位元組不帶正負號的整數。 - - 已經關閉。 - 發生 I/O 錯誤。 - 1 - - - 以非同步方式將行結束字元寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將一個字元 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入到文字資料流的字元陣列。如果字元陣列是 null，則只有行結束字元會被寫入。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字元子陣列 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 資料寫入來源的字元陣列。 - 緩衝區中要開始擷取資料的字元位置。 - 要寫入的字元數。 - - 為 null。 - - 加上 大於緩衝區的長度。 - - 或 為負值。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - 以非同步方式將字串 (其後加上行結束字元) 寫入到文字字串或資料流。 - 表示非同步寫入作業的工作。 - 要寫入的字串。如果值為 null，則只會寫入行結束字元。 - 文字寫入器已處置。 - 文字寫入器目前由先前寫入作業所使用。 - - - \ No newline at end of file diff --git a/packages/System.IO.4.1.0/ref/portable-net45+win8+wp8+wpa81/_._ b/packages/System.IO.4.1.0/ref/portable-net45+win8+wp8+wpa81/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/win8/_._ b/packages/System.IO.4.1.0/ref/win8/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/wp80/_._ b/packages/System.IO.4.1.0/ref/wp80/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/wpa81/_._ b/packages/System.IO.4.1.0/ref/wpa81/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/xamarinios10/_._ b/packages/System.IO.4.1.0/ref/xamarinios10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/xamarinmac20/_._ b/packages/System.IO.4.1.0/ref/xamarinmac20/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/xamarintvos10/_._ b/packages/System.IO.4.1.0/ref/xamarintvos10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/System.IO.4.1.0/ref/xamarinwatchos10/_._ b/packages/System.IO.4.1.0/ref/xamarinwatchos10/_._ deleted file mode 100644 index e69de29b..00000000 diff --git a/packages/repositories.config b/packages/repositories.config deleted file mode 100644 index c0a3978c..00000000 --- a/packages/repositories.config +++ /dev/null @@ -1,9 +0,0 @@ - - - - - - - - - \ No newline at end of file From 8ae915271b30dd8129e68b741fd987259afb7ac2 Mon Sep 17 00:00:00 2001 From: drieseng Date: Sat, 9 Jul 2016 17:29:38 +0200 Subject: [PATCH 10/16] Update SshNet.Security.Cryptography v1.2.0. Added .NETStandard 1.3 to nuspec. Prepare for 2016.0.0-beta3. --- build/nuget/SSH.NET.nuspec | 49 ++++++++++++++++--- src/Renci.SshNet.NETCore/project.json | 21 +++----- .../Renci.SshNet.Silverlight5.csproj | 6 +-- src/Renci.SshNet.Silverlight5/packages.config | 2 +- src/Renci.SshNet.UAP10/project.json | 4 +- .../Renci.SshNet.WindowsPhone8.csproj | 6 +-- .../packages.config | 2 +- .../Properties/CommonAssemblyInfo.cs | 2 +- 8 files changed, 60 insertions(+), 32 deletions(-) diff --git a/build/nuget/SSH.NET.nuspec b/build/nuget/SSH.NET.nuspec index 690564b8..9bb5e991 100644 --- a/build/nuget/SSH.NET.nuspec +++ b/build/nuget/SSH.NET.nuspec @@ -2,7 +2,7 @@ SSH.NET - 2016.0.0-beta1 + 2016.0.0-beta3 SSH.NET Renci olegkap,drieseng @@ -10,7 +10,14 @@ https://github.com/sshnet/SSH.NET/ false SSH.NET is a Secure Shell (SSH) library for .NET, optimized for parallelism and with broad framework support. - 2016.0.0-beta2 + 2016.0.0-beta3 +============== + +New Features: + + * Added support for .NET Core 1.0 (.NETStandard 1.3) + +2016.0.0-beta2 ============== Changes: @@ -127,21 +134,47 @@ Fixes: en-US ssh scp sftp + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - - + + diff --git a/src/Renci.SshNet.NETCore/project.json b/src/Renci.SshNet.NETCore/project.json index 46d8209a..bb01ad95 100644 --- a/src/Renci.SshNet.NETCore/project.json +++ b/src/Renci.SshNet.NETCore/project.json @@ -22,27 +22,27 @@ "netstandard1.3": { "dependencies": { "Microsoft.CSharp": "4.0.1", - "System.IO": "4.1.0", + "SshNet.Security.Cryptography": "[1.2.0]", + "System.Diagnostics.Debug": "4.0.11", + "System.Diagnostics.Tools": "4.0.1", "System.Diagnostics.TraceSource": "4.0.0", - "System.Security.Cryptography.Algorithms": "4.2.0", - "System.Linq": "4.1.0", "System.Globalization": "4.0.11", + "System.IO": "4.1.0", "System.IO.FileSystem": "4.0.1", "System.IO.FileSystem.Primitives": "4.0.1", + "System.Linq": "4.1.0", "System.Net.NameResolution": "4.0.0", "System.Net.Sockets": "4.1.0", "System.Reflection.Extensions": "4.0.1", "System.Runtime.Extensions": "4.1.0", + "System.Security.Cryptography.Algorithms": "4.2.0", + "System.Text.RegularExpressions": "4.1.0", "System.Threading": "4.0.11", "System.Threading.Thread": "4.0.0", "System.Threading.ThreadPool": "4.0.10", "System.Threading.Timer": "4.0.1", - "System.Text.RegularExpressions": "4.1.0", "System.Xml.XmlDocument": "4.0.1", - "System.Xml.XPath.XmlDocument": "4.0.1", - "System.Diagnostics.Tools": "4.0.1", - "System.Diagnostics.Debug": "4.0.11", - "SshNet.Security.Cryptography": "1.1.0" + "System.Xml.XPath.XmlDocument": "4.0.1" }, "buildOptions": { "define": [ @@ -73,10 +73,5 @@ ] } } - }, - "scripts": { - "postcompile": [ - "dotnet pack --no-build --configuration %compile:Configuration%" - ] } } diff --git a/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj b/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj index a73a42f8..d16fdf67 100644 --- a/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj +++ b/src/Renci.SshNet.Silverlight5/Renci.SshNet.Silverlight5.csproj @@ -62,8 +62,8 @@ - - ..\..\packages\SshNet.Security.Cryptography.1.1.0\lib\sl5\SshNet.Security.Cryptography.dll + + ..\..\packages\SshNet.Security.Cryptography.1.2.0\lib\sl5\SshNet.Security.Cryptography.dll True @@ -917,7 +917,7 @@ - +

@d5D(Pi5#)jq`u?kN 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� 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�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ⅆ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]mymq>Fj)NLSbQF}e}hcmaFL4{GxCwxH{5_>F< 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�rD$%UAtr}1D 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 NZj1`M+FJ61V)F~g{VPmzc^F6H4 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˰w_MYshcAs6 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�-TP#td6L!C{ zjvBSt{m!~-bkFV&R;rP|{aw~yqb&P-Y=lOY_Cy)4(bM)!nXb_udsV5|sM+4AEY!&4 zU{Y3Tla-_l@Dob&Zl-BNXo!B#FDoNG0?IdAyvB7{{sY3$4e}Z%$E4&llwR zXNc_J8Lcz|9VgIZNrId4@P?D@{H!W!l_DGqj|1&7_Ds9Jeg~?^0MZ6!fCA1 z4$g-qWLm{zN#m4^7bNWgdi}-LGj5Y{oO0?#d0dN6XpC2ui?0yFHRd|cN0ogVZS$O{ zoYCktkYBvVY}5zpz$6`-d~$&u-Fy7JRYGGF(|EagR@dQLaV6Utbu^Y7I@`3dD8S`>d;r@Sl4q(r52`UuHBDwETfKy}0`%AY=| zh~HipF@vN2@_bTh0OD7bQ4U`9%4bLeZG*jLD_4*%+2nZ5Rc>iCz-zvu?rim(;F6)7jT)8PI(To^XrQg1_ZE$g*u;8o)lstdc8xCBWP9(>=#ou0@14p3%-%by z+4n1&QrDs_fDz+55OM zb|OuS+UNbQat7(is6*cGE4Ke=rL*3IodsAM z&BC^EcZyqaFIJ$qySsZS(gMXTI20`|#S*kwf#Sv8-6`%4!3qB7ecyA=cjPCLc%;|P}K>08OJ!*3ZCu?v)1 zPPME>rYbeG@09OQ2L&@&K&-zX&Y9xcc2<61NZ1pN0@~D5sp69<9ZoI_U64vR7bo{v zcaY*+(Cjs0txO(P=S0~R*E{E`R@ePC47_llKT#V^H0P)zo12D*kaB$9(Nr=m1*WFQ z%J$zGYqZJSGYKY4W6KleYY99>U5)Rvfhq}>q!MR{B|7Dw#VO(w1Dj~C5lW>qVBW&p zp-xy9oQNAGV8KyH-oxy}LvIJ$q?(Z3u$h^3@Q3B(QLX@h*IM`2234Uw+s zrgU>=<>DX#5b|$PWl7Y~*j8gZ(9=5V()Y-5; zqz7aYG|3F0?S@;-1(uk0w)Nj34+u?x_}<6iqAzr{b` z&nc9jb3k;ELW2VMswO{#z_&gksnd z7+dx!^Bfa-*C16I5p?PGHHGehn;pT71^;j3I)x;{J0gR(ipLrfYw8j!Z*b5}RzM+m|()0A*RbbJGLY8s6p=_99Ht zhPQaPH-u42ZzeVRw=qviNp`sd?xSUU2QvZw8eO#jRzH8O#P^~#182>NU+K6XE8OJp zNc{EgX(KV(S#=iF5;p3&5f$G5Djz`d_CojnL0@$ZhiUo5U-G(3XybC{L;`DRu0 z_q?eIrnX!KqYd;~%t6{VjcS0s_U=*6A~5*`GFxAnPa367tbTG-u>0}t=)A#or^htQ zV@Zu5(qT_?>!r8JmO`VzTAN2zK~dft zs5NJ&U?&_E*F;pp6SrArDlvrY0x*iLfV_>VT%=F{koKujpw>=lXH^f+t7S*dq-g~< zkrxAFlm*tw3j9OddUlJQitQg#g$^zMBo2K0p#-aOn24felGP-OX8l(DwCUcru;&(W)1py0+{YrR!~TvKvg3Wyi__J|2%}XA-%;0 zjI>8qp!?w}uAXNfJ=1ns7%1&-B@}HFrMPLm@{o<_(C>t7a`GrCAJs&rFxY5wnByO` zo#r}1tFw}A5t;b?wBJdwC7p;O{yU}2J>9s7u*yod)w!~s-0oqC5fE6vCI>XRdV43T zI6kjsWhUZ~Bz=fhA^p8<9?9^Kd*(+%@S7>#u*#nI#jXiGYs@?|z49Ig2g{e;8sfW| zVd0H?dx^G1G`Kr>ngkOBSIe5(T?hBYbASyXiG9+kmLA2dR^mY0W@1O|;U;Qolj@

@d5D(Pi5#)jq`u?kN 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� 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